init frontend

services/frontend/src/app/api/auth.ts

@@ -0,0 +1,24 @@
+import { apiSlice } from '../features/api'
+import { convertRawAuthData } from '../types/auth'
+
+import type { AuthData } from '../types/common'
+import type { LoginRequest, RawAuthResponse } from '../types/auth'
+
+export const authApiSlice = apiSlice.injectEndpoints({
+  endpoints: (builder) => ({
+    login: builder.mutation<AuthData, LoginRequest>({
+      query: data => ({
+        url: '/v1/auth/login',
+        method: 'POST',
+        body: { ...data }
+      }),
+      transformResponse: (response: RawAuthResponse) => {
+        if (response.data === undefined) { throw Error('invalid auth response') }
+
+        return convertRawAuthData(response.data)
+      },
+    }),
+  })
+})
+
+export const { useLoginMutation } = authApiSlice

services/frontend/src/app/api/comments.ts

@@ -0,0 +1,68 @@
+import { apiSlice } from '../features/api'
+import { convertRawComment } from '../types/comments'
+
+import type { Comment } from '../types/common'
+import type {
+  RawComment, RawCommentResponse, RawCommentsResponse,
+  GetPostCommentsRequest,
+  UpdatePostCommentRequest,
+  DeletePostCommentRequest,
+  CreatePostCommentRequest
+} from '../types/comments'
+
+export const commentsApiSlice = apiSlice.injectEndpoints({
+  endpoints: (builder) => ({
+    getPostComments: builder.query<Comment[], GetPostCommentsRequest>({
+      query: data => ({ url: `/v1/posts/${data.postId}/comments` }),
+      transformResponse: (response: RawCommentsResponse) => {
+        if (response.data === undefined) {
+          throw Error('invalid comments response')
+        } else if (!response.data.comments) {
+          return []
+        }
+
+        return response.data.comments.map<Comment>((rawComment: RawComment) => convertRawComment(rawComment))
+      }
+    }),
+
+    updatePostComment: builder.mutation<Comment, UpdatePostCommentRequest>({
+      query: req => ({
+        url: `/v1/posts/${req.postId}/comments/${req.id}`,
+        method: 'PATCH',
+        body: { ...req.data }
+      }),
+      transformResponse: (response: RawCommentResponse) => {
+        if (response.data === undefined) { throw Error('invalid comment response') }
+
+        return convertRawComment(response.data)
+      }
+    }),
+
+    deletePostComment: builder.mutation<void, DeletePostCommentRequest>({
+      query: req => ({
+        url: `/v1/posts/${req.postId}/comments/${req.id}`,
+        method: 'DELETE'
+      })
+    }),
+
+    createPostComment: builder.mutation<Comment, CreatePostCommentRequest>({
+      query: req => ({
+        url: `/v1/posts/${req.postId}/comments`,
+        method: 'POST',
+        body: { ...req.data }
+      }),
+      transformResponse: (response: RawCommentResponse) => {
+        if (response.data === undefined) { throw Error('invalid comment response') }
+
+        return convertRawComment(response.data)
+      }
+    }),
+  })
+})
+
+export const {
+  useGetPostCommentsQuery,
+  useUpdatePostCommentMutation,
+  useDeletePostCommentMutation,
+  useCreatePostCommentMutation
+} = commentsApiSlice

services/frontend/src/app/api/panels.ts

@@ -0,0 +1,93 @@
+import { apiSlice } from '../features/api'
+import { convertRawPanel } from '../types/panels'
+
+import type { Panel } from '../types/common'
+import type {
+  RawPanelResponse,
+  GetPanelByIdRequest, GetPanelByNameRequest,
+  UpdatePanelByIdRequest, UpdatePanelByNameRequest,
+  DeletePanelByIdRequest, DeletePanelByNameRequest,
+  CreatePanelRequest
+} from '../types/panels'
+
+export const panelsApiSlice = apiSlice.injectEndpoints({
+  endpoints: (builder) => ({
+    getPanelById: builder.query<Panel, GetPanelByIdRequest>({
+      query: req => ({ url: `/v1/panels/id/${req.id}` }),
+      transformResponse: (response: RawPanelResponse) => {
+        if (response.data === undefined) { throw Error('invalid panel response') }
+
+        return convertRawPanel(response.data)
+      }
+    }),
+
+    getPanelByName: builder.query<Panel, GetPanelByNameRequest>({
+      query: req => ({ url: `/v1/panels/name/${req.name}` }),
+      transformResponse: (response: RawPanelResponse) => {
+        if (response.data === undefined) { throw Error('invalid panel response') }
+
+        return convertRawPanel(response.data)
+      }
+    }),
+
+    updatePanelById: builder.mutation<Panel, UpdatePanelByIdRequest>({
+      query: req => ({
+        url: `/v1/panels/id/${req.id}`,
+        method: 'PATCH',
+        body: { ...req.data }
+      }),
+      transformResponse: (response: RawPanelResponse) => {
+        if (response.data === undefined) { throw Error('invalid panel response') }
+
+        return convertRawPanel(response.data)
+      }
+    }),
+
+    updatePanelByName: builder.mutation<Panel, UpdatePanelByNameRequest>({
+      query: req => ({
+        url: `/v1/panels/name/${req.name}`,
+        method: 'PATCH',
+        body: { ...req.data }
+      }),
+      transformResponse: (response: RawPanelResponse) => {
+        if (response.data === undefined) { throw Error('invalid panel response') }
+
+        return convertRawPanel(response.data)
+      }
+    }),
+
+    deletePanelById: builder.mutation<void, DeletePanelByIdRequest>({
+      query: req => ({
+        url: `/v1/panels/id/${req.id}`,
+        method: 'DELETE'
+      })
+    }),
+
+    deletePanelByName: builder.mutation<void, DeletePanelByNameRequest>({
+      query: req => ({
+        url: `/v1/panels/id/${req.name}`,
+        method: 'DELETE'
+      })
+    }),
+
+    createPanel: builder.mutation<Panel, CreatePanelRequest>({
+      query: req => ({
+        url: '/v1/panels',
+        method: 'POST',
+        body: { ...req }
+      }),
+      transformResponse: (response: RawPanelResponse) => {
+        if (response.data === undefined) { throw Error('invalid panel response') }
+
+        return convertRawPanel(response.data)
+      }
+    }),
+  })
+})
+
+export const { 
+  useGetPanelByIdQuery, useGetPanelByNameQuery,
+  useUpdatePanelByIdMutation, useUpdatePanelByNameMutation,
+  useDeletePanelByIdMutation, useDeletePanelByNameMutation,
+  useCreatePanelMutation 
+} = panelsApiSlice

services/frontend/src/app/api/posts.ts

@@ -0,0 +1,107 @@
+import { apiSlice } from '../features/api'
+import { convertRawPost } from '../types/posts'
+
+import type { Post } from '../types/common'
+import type {
+  RawPost, RawPostResponse, RawPostsResponse,
+  GetPanelPostRequest, GetPanelPostsRequest,
+  GetUserPostsRequest,
+  UpdatePostRequest,
+  DeletePostRequest,
+  CreatePostRequest
+} from '../types/posts'
+
+export const postsApiSlice = apiSlice.injectEndpoints({
+  endpoints: (builder) => ({
+    getPanelPost: builder.query<Post, GetPanelPostRequest>({
+      query: req => ({ url: `/v1/panels/id/${req.panelId}/posts/${req.id}` }),
+      transformResponse: (response: RawPostResponse) => {
+        if (response.data === undefined) { throw Error('invalid post response') }
+
+        return convertRawPost(response.data)
+      }
+    }),
+
+    getFeedPosts: builder.query<Post[], void>({
+      query: () => '/v1/posts/feed',
+      transformResponse: (response: RawPostsResponse) => {
+        if (response.data === undefined) {
+          throw Error('invalid posts response')
+        } else if (!response.data.posts) {
+          return []
+        }
+
+        return response.data.posts.map<Post>((rawPost: RawPost) => convertRawPost(rawPost))
+      }
+    }),
+
+    getUserPosts: builder.query<Post[], GetUserPostsRequest>({
+      query: req => `/v1/users/id/${req.userId}/posts`,
+      transformResponse: (response: RawPostsResponse) => {
+        if (response.data === undefined) {
+          throw Error('invalid posts response')
+        } else if (!response.data.posts) {
+          return []
+        }
+
+        return response.data.posts.map<Post>((rawPost: RawPost) => convertRawPost(rawPost))
+      }
+    }),
+
+    getPanelPosts: builder.query<Post[], GetPanelPostsRequest>({
+      query: req => `/v1/panels/id/${req.panelId}/posts`,
+      transformResponse: (response: RawPostsResponse) => {
+        if (response.data === undefined) {
+          throw Error('invalid posts response')
+        } else if (!response.data.posts) {
+          return []
+        }
+
+        return response.data.posts.map<Post>((rawPost: RawPost) => convertRawPost(rawPost))
+      }
+    }),
+
+    updatePost: builder.mutation<Post, UpdatePostRequest>({
+      query: req => ({
+        url: `/v1/posts/${req.id}`,
+        method: 'PATCH',
+        body: { ...req.data },
+      }),
+      transformResponse: (response: RawPostResponse) => {
+        if (response.data === undefined) { throw Error('invalid post response') }
+
+        return convertRawPost(response.data)
+      }
+    }),
+
+    deletePost: builder.mutation<void, DeletePostRequest>({
+      query: req => ({
+        url: `/v1/posts/${req.id}`,
+        method: 'DELETE',
+      })
+    }),
+
+    createPanelPost: builder.mutation<Post, CreatePostRequest>({
+      query: req => ({
+        url: `/v1/panels/id/${req.panelId}`,
+        method: 'POST',
+        body: { ...req.data },
+      }),
+      transformResponse: (response: RawPostResponse) => {
+        if (response.data === undefined) { throw Error('invalid post response') }
+
+        return convertRawPost(response.data)
+      }
+    }),
+  })
+})
+
+export const { 
+  useGetPanelPostQuery,
+  useGetFeedPostsQuery,
+  useGetUserPostsQuery,
+  useGetPanelPostsQuery,
+  useUpdatePostMutation,
+  useDeletePostMutation,
+  useCreatePanelPostMutation
+} = postsApiSlice

services/frontend/src/app/api/users.ts

@@ -0,0 +1,83 @@
+import { apiSlice } from '../features/api'
+import { convertRawUser } from '../types/user'
+import { convertRawAuthData } from '../types/auth'
+
+import type { User, AuthData } from '../types/common'
+import type { RawAuthResponse } from '../types/auth'
+import type {
+  RawUserResponse,
+  GetUserByIdRequest, GetUserByNameRequest,
+  DeleteUserByIdRequest, DeleteUserByNameRequest,
+  RegisterUserRequest
+} from '../types/user'
+
+export const usersApiSlice = apiSlice.injectEndpoints({
+  endpoints: (builder) => ({
+    getUserById: builder.query<User, GetUserByIdRequest>({
+      query: req => ({ url: `/v1/users/id/${req.id}` }),
+      transformResponse: (response: RawUserResponse) => {
+        if (response.data === undefined) { throw Error('invalid user response') }
+
+        return convertRawUser(response.data)
+      }
+    }),
+
+    getUserByName: builder.query<User, GetUserByNameRequest>({
+      query: req => ({ url: `/v1/users/username/${req.username}` }),
+      transformResponse: (response: RawUserResponse) => {
+        if (response.data === undefined) { throw Error('invalid user response') }
+
+        return convertRawUser(response.data)
+      }
+    }),
+
+    getCurrentUser: builder.query<User, void>({
+      query: () => ({ url: '/v1/users/me' }),
+      transformResponse: (response: RawUserResponse) => {
+        if (response.data === undefined) { throw Error('invalid user response') }
+
+        return convertRawUser(response.data)
+      }
+    }),
+
+    deleteUserById: builder.mutation<void, DeleteUserByIdRequest>({
+      query: req => ({
+        url: `/v1/users/id/${req.id}`,
+        method: 'DELETE'
+      })
+    }),
+
+    deleteUserByName: builder.mutation<void, DeleteUserByNameRequest>({
+      query: req => ({
+        url: `/v1/users/username/${req.username}`,
+        method: 'DELETE'
+      })
+    }),
+
+    deleteCurrentUser: builder.mutation<void, void>({
+      query: () => ({
+        url: '/v1/users/me',
+        method: 'DELETE'
+      })
+    }),
+
+    registerUser: builder.mutation<AuthData, RegisterUserRequest>({
+      query: req => ({
+        url: '/v1/users',
+        method: 'POST',
+        body: { ...req }
+      }),
+      transformResponse: (response: RawAuthResponse) => {
+        if (response.data === undefined) { throw Error('invalid registration response') }
+
+        return convertRawAuthData(response.data)
+      }
+    }),
+  })
+})
+
+export const { 
+  useGetUserByIdQuery, useGetUserByNameQuery, useGetCurrentUserQuery, 
+  useDeleteUserByIdMutation, useDeleteUserByNameMutation, useDeleteCurrentUserMutation, 
+  useRegisterUserMutation 
+} = usersApiSlice