Feat: connect front back

package.json

@@ -8,7 +8,10 @@
     "build": "npm-run-all --parallel build:client build:server",
     "build:client": "vite build --ssrManifest --outDir dist/client",
     "build:server": "vite build --ssr entry-server.tsx --outDir dist/server",
-    "dev": "tsx watch --ignore node_modules src/back/index.ts",
+    "dev:back": "tsx watch --ignore ./ src/back/index.ts",
+    "dev:csr": "vite",
+    "dev:ssr": "tsx src/back/frontDevServer.ts",
+    "dev": "npm-run-all --parallel dev:back dev:csr",
     "production:back": "cross-env NODE_ENV=production tsx src/back/index.ts",
     "preview": "npm-run-all --serial build production:back",
     "deploy": "npm-run-all --serial prisma:generate prisma:deploy preview",

src/DTO/index.dto.ts

@@ -12,32 +12,29 @@ export const AuthorizationHeader = {
 type ErrorSchema = {
   type: 'object',
   description: string,
-  required: ['error','message','toast'],
+  required: ['error','message'],
   properties: {
     error: { type: 'string', enum: string[] },
     message: { type: 'string'},
-    toast: { type: 'string', enum: string[] }
   }
 };
 
 export const errorSchema = (...errors: Array<new (message:string,...any:any) => ErrorWithToast>) => {
-  const errorConfigs = ErrorConfig.filter((errorConfig) => errors.some((error) => errorConfig.error === error));
+  const errorConfigs = errors.map((error) => ErrorConfig[error.name]);
   return errorConfigs.reduce((acc, cur) => {
     const errorInstance = new cur.error("");
     if(acc[cur.code]) {
       acc[cur.code].properties.error.enum.push(errorInstance.name);
       acc[cur.code].description += `\n${cur.describtion}`;
-      acc[cur.code].properties.toast.enum.push(cur.toast(errorInstance));
       return acc;
     }
     acc[cur.code] = {
       type: 'object',
       description: cur.describtion,
-      required: ['error','message','toast'],
+      required: ['error','message'],
       properties: {
         error: { type: 'string', enum: [errorInstance.name] },
         message: { type: 'string'},
-        toast: { type: 'string', enum: [cur.toast(errorInstance)] }
       }
     }
     return acc;

src/DTO/user.dto.ts

@@ -26,6 +26,9 @@ export const signUpSchema = {
         },
       },
       ...errorSchema(
+        E.ValidationError,
+        E.NotCorrectTypeError,
+        E.ExistError,
       )
     },
 } as const;
@@ -51,6 +54,7 @@ export const signInSchema = {
         },
       },
       ...errorSchema(
+        E.ValidationError,
         E.NotFoundError
       )
     },
@@ -82,6 +86,8 @@ export const refreshSchema = {
             },
         },
         ...errorSchema(
+          E.NoAuthorizationInCookieError,
+          E.UserAuthorizationError
         )
     },
 } as const;
@@ -121,3 +127,4 @@ export type signUpInterface = SchemaToInterface<typeof signUpSchema>;
 export type signInInterface = SchemaToInterface<typeof signInSchema>;
 export type signOutInterface = SchemaToInterface<typeof signOutSchema>;
 export type refreshInterface = SchemaToInterface<typeof refreshSchema> & { Body: { userId: string } };
+export type profileInterface = SchemaToInterface<typeof profileSchema> & { Body: { userId: string } };

src/DTO/vocaList.dto.ts

@@ -10,7 +10,7 @@ export const getVocaListSchema = {
   tags: ['Voca'],
   summary: '단어 목록 조회',
   headers: AuthorizationHeader,
-  querystring: {
+  params: {
     type: 'object',
     required: ['bookId'],
     properties: {
@@ -129,7 +129,7 @@ export const deleteVocaSchema = {
   tags: ['Voca'],
   summary: '단어 삭제',
   headers: AuthorizationHeader,
-  body: {
+  params: {
     type: 'object',
     required: ['vocaId'],
     properties: {

src/DTO/wordbook.dto.ts

@@ -1,110 +1,95 @@
 import {
-    AuthorizationHeader,
-    errorSchema,
-  } from '@DTO/index.dto';
+  AuthorizationHeader,
+  errorSchema,
+} from '@DTO/index.dto';
 import * as E from '@errors';
 import { SchemaToInterface } from 'fastify-schema-to-ts';
 
-//getWordbookList, addWordbook, hideWordbook, showWordbook
-
 const wordbookType = {
-    type: 'array',
-    items: {
-      type: 'object',
-      required: ['id', 'title', 'createdAt', 'isHidden', 'vocaCount'],
-      properties: {
-        id: { type: 'number' },
-        title: { type: 'string' },
-        createdAt: { type: 'string' },
-        isHidden: { type: 'boolean' },
-        vocaCount: { type: 'number' },
-      },
+  type: 'array',
+  items: {
+    type: 'object',
+    required: ['id', 'title', 'createdAt', 'isHidden', 'vocaCount'],
+    properties: {
+      id: { type: 'number' },
+      title: { type: 'string' },
+      createdAt: { type: 'string' },
+      isHidden: { type: 'boolean' },
+      vocaCount: { type: 'number' },
     },
+  },
+} as const;
+
+const returnType = {
+  type: "object",
+  required: ['wordbookList', 'hiddenWordbookList'],
+  properties: {
+    wordbookList: wordbookType,
+    hiddenWordbookList: wordbookType,
+  },
 } as const;
 
 export const getWordbookListSchema = {
-    tags: ['Wordbook'],
-    summary: '단어장 목록 조회',
-    headers: AuthorizationHeader,
-    response: {
-      200: {
-        type: "array",
-        items: [wordbookType,wordbookType],
-        minItems: 2,
-        maxItems: 2,
-      },
-      ...errorSchema(
-      )
-    },
+  tags: ['Wordbook'],
+  summary: '단어장 목록 조회',
+  headers: AuthorizationHeader,
+  response: {
+    200: returnType,
+  },
 } as const;
 
 export const createWordbookSchema = {
-    tags: ['Wordbook'],
-    summary: '단어장 목록 조회',
-    headers: AuthorizationHeader,
-    body: {
-      type: 'object',
-      required: ['title'],
-      properties: {
-        title: { type: 'string' },
-      },
+  tags: ['Wordbook'],
+  summary: '단어장 목록 조회',
+  headers: AuthorizationHeader,
+  body: {
+    type: 'object',
+    required: ['title'],
+    properties: {
+      title: { type: 'string' },
     },
-    response: {
-        201: {
-          type: "array",
-          items: [wordbookType,wordbookType],
-          minItems: 2,
-          maxItems: 2,
-        },
-        ...errorSchema(
-        )
-      },
+  },
+  response: {
+    201: returnType,
+    ...errorSchema(
+    )
+  },
 } as const;
 
 export const hideWordbookSchema = {
-    tags: ['Wordbook'],
-    summary: '단어장 숨기기',
-    headers: AuthorizationHeader,
-    body: {
-      type: 'object',
-      required: ['bookId'],
-      properties: {
-        bookId: { type: 'number' },
-      },
+  tags: ['Wordbook'],
+  summary: '단어장 숨기기',
+  headers: AuthorizationHeader,
+  body: {
+    type: 'object',
+    required: ['bookId'],
+    properties: {
+      bookId: { type: 'number' },
     },
-    response: {
-        200: {
-          type: "array",
-          items: [wordbookType,wordbookType],
-          minItems: 2,
-          maxItems: 2,
-        },
-        ...errorSchema(
-        )
-      },
+  },
+  response: {
+    200: returnType,
+    ...errorSchema(
+    )
+  },
 } as const;
 
 export const showWordbookSchema = {
-    tags: ['Wordbook'],
-    summary: '단어장 보이기',
-    headers: AuthorizationHeader,
-    body: {
-      type: 'object',
-      required: ['bookId'],
-      properties: {
-        bookId: { type: 'number' },
-      },
+  tags: ['Wordbook'],
+  summary: '단어장 보이기',
+  headers: AuthorizationHeader,
+  body: {
+    type: 'object',
+    required: ['bookId'],
+    properties: {
+      bookId: { type: 'number' },
     },
-    response: {
-        200: {
-          type: "array",
-          items: [wordbookType,wordbookType],
-          minItems: 2,
-          maxItems: 2,
-        },
-        ...errorSchema(
-        )
-      },
+  },
+  response: {
+    200: returnType,
+    ...errorSchema(
+    )
+  },
 } as const;
 
 export type getWordbookListInterface = SchemaToInterface<typeof getWordbookListSchema> & { Body: { userId: string } };

src/back/api/hooks/checkRefreshToken.ts

@@ -1,6 +1,6 @@
 import { LoginToken } from '@serverUtils/jwt';
 import { FastifyRequest, FastifyReply, FastifyError } from 'fastify';
-import { UserAuthorizationError, NoAuthorizationInHeaderError } from '@errors/index';
+import { NoAuthorizationInCookieError } from '@errors/index';
 
 export default async (
   request: FastifyRequest<{ Body: { userId: string } }>,
@@ -9,7 +9,7 @@ export default async (
 ) => {
   const authorization = request.cookies.authorization;
   if (!authorization) {
-    throw new NoAuthorizationInHeaderError('쿠키에 Authorization이 없습니다');
+    throw new NoAuthorizationInCookieError('쿠키에 Authorization이 없습니다');
   }
 
   if(!request.body)

src/back/api/hooks/checkUser.ts

@@ -1,6 +1,6 @@
 import { LoginToken } from '@serverUtils/jwt';
 import { FastifyRequest, FastifyReply, FastifyError } from 'fastify';
-import { UserAuthorizationError, NoAuthorizationInHeaderError } from '@errors/index';
+import { NoAuthorizationInHeaderError } from '@errors/index';
 
 export default async (
   request: FastifyRequest<{ Body: { userId: string } }>,

src/back/api/index.ts

@@ -7,7 +7,7 @@ import wordbook from './routes/wordbook';
 const api: FastifyPluginAsync = async (server: FastifyInstance) => {
   server.register(test, { prefix: '/' });
   server.register(user, { prefix: '/user' });
-  server.register(vocaList, { prefix: '/vocaList' });
+  server.register(vocaList, { prefix: '/voca' });
   server.register(wordbook, { prefix: '/wordbook' });
 };
 

src/back/api/routes/apiTest.ts

@@ -1,5 +1,4 @@
 import { FastifyInstance, FastifyPluginAsync, FastifySchema } from 'fastify';
-import onError from '@fastifyHooks/onError';
 import { NotDefinedOnConfigError } from '@errors/index';
 
 const test: FastifyPluginAsync = async (server: FastifyInstance) => {
@@ -16,10 +15,10 @@ const test: FastifyPluginAsync = async (server: FastifyInstance) => {
   server.get('/ping', { schema: testSchema }, async (req, rep) => {
     return { data: 'pong' };
   });
-  server.post('/notDefinedOnConfigerror', { onError }, async (req, rep) => {
+  server.post('/notDefinedOnConfigerror', async (req, rep) => {
     throw new NotDefinedOnConfigError('notDefinedOnConfigerror');
   });
-  server.post('/notDefinederror', { onError }, async (req, rep) => {
+  server.post('/notDefinederror', async (req, rep) => {
     throw new Error('notDefinederror');
   });
 };