重构

src/modules/folder/folder-aciton.ts

@@ -0,0 +1,202 @@
+"use server";
+
+import { ValidateError } from "@/lib/errors";
+import { ActionInputCreatePair, ActionInputUpdatePairById, ActionOutputGetFoldersWithTotalPairsByUserId, validateActionInputCreatePair, validateActionInputUpdatePairById } from "./folder-action-dto";
+import { repoCreateFolder, repoCreatePair, repoDeleteFolderById, repoDeletePairById, repoGetFoldersByUserId, repoGetFoldersWithTotalPairsByUserId, repoGetPairsByFolderId, repoGetUserIdByFolderId, repoRenameFolderById, repoUpdatePairById } from "./folder-repository";
+import { validate } from "@/utils/validate";
+import z from "zod";
+import { LENGTH_MAX_FOLDER_NAME, LENGTH_MIN_FOLDER_NAME } from "@/shared/constant";
+
+export async function actionGetPairsByFolderId(folderId: number) {
+    try {
+        return {
+            success: true,
+            message: 'success',
+            data: await repoGetPairsByFolderId(folderId)
+        };
+    } catch (e) {
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionUpdatePairById(id: number, dto: ActionInputUpdatePairById) {
+    try {
+        const validatedDto = validateActionInputUpdatePairById(dto);
+        await repoUpdatePairById(id, validatedDto);
+        return {
+            success: true,
+            message: 'success',
+        };
+    } catch (e) {
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionGetUserIdByFolderId(folderId: number) {
+    try {
+        return {
+            success: true,
+            message: 'success',
+            data: await repoGetUserIdByFolderId(folderId)
+        };
+    } catch (e) {
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionDeleteFolderById(folderId: number) {
+    try {
+        await repoDeleteFolderById(folderId);
+        return {
+            success: true,
+            message: 'success',
+        };
+    } catch (e) {
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionDeletePairById(id: number) {
+    try {
+        await repoDeletePairById(id);
+        return {
+            success: true,
+            message: 'success'
+        };
+    } catch (e) {
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionGetFoldersWithTotalPairsByUserId(id: string): Promise<ActionOutputGetFoldersWithTotalPairsByUserId> {
+    try {
+        return {
+            success: true,
+            message: 'success',
+            data: await repoGetFoldersWithTotalPairsByUserId(id)
+        };
+    } catch (e) {
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionGetFoldersByUserId(userId: string) {
+    try {
+        return {
+            success: true,
+            message: 'success',
+            data: await repoGetFoldersByUserId(userId)
+        };
+    } catch (e) {
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionCreatePair(dto: ActionInputCreatePair) {
+    try {
+        const validatedDto = validateActionInputCreatePair(dto);
+        await repoCreatePair(validatedDto);
+        return {
+            success: true,
+            message: 'success'
+        };
+    } catch (e) {
+        if (e instanceof ValidateError) {
+            return {
+                success: false,
+                message: e.message
+            };
+        }
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionCreateFolder(userId: string, folderName: string) {
+    try {
+        const validatedFolderName = validate(folderName,
+            z.string()
+                .trim()
+                .min(LENGTH_MIN_FOLDER_NAME)
+                .max(LENGTH_MAX_FOLDER_NAME));
+        await repoCreateFolder({
+            name: validatedFolderName,
+            userId: userId
+        });
+        return {
+            success: true,
+            message: 'success'
+        };
+    } catch (e) {
+        if (e instanceof ValidateError) {
+            return {
+                success: false,
+                message: e.message
+            };
+        }
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}
+
+export async function actionRenameFolderById(id: number, newName: string) {
+    try {
+        const validatedNewName = validate(
+            newName,
+            z.string()
+                .min(LENGTH_MIN_FOLDER_NAME)
+                .max(LENGTH_MAX_FOLDER_NAME)
+                .trim());
+        await repoRenameFolderById(id, validatedNewName);
+        return {
+            success: true,
+            message: 'success'
+        };
+    } catch (e) {
+        if (e instanceof ValidateError) {
+            return {
+                success: false,
+                message: e.message
+            };
+        }
+        console.log(e);
+        return {
+            success: false,
+            message: 'Unknown error occured.'
+        };
+    }
+}

src/modules/folder/folder-action-dto.ts

@@ -0,0 +1,34 @@
+import { LENGTH_MAX_FOLDER_NAME, LENGTH_MAX_IPA, LENGTH_MAX_LANGUAGE, LENGTH_MAX_PAIR_TEXT, LENGTH_MIN_FOLDER_NAME, LENGTH_MIN_IPA, LENGTH_MIN_LANGUAGE, LENGTH_MIN_PAIR_TEXT } from "@/shared/constant";
+import { TSharedFolderWithTotalPairs } from "@/shared/folder-type";
+import { generateValidator } from "@/utils/validate";
+import z from "zod";
+
+export const schemaActionInputCreatePair = z.object({
+    text1: z.string().min(LENGTH_MIN_PAIR_TEXT).max(LENGTH_MAX_PAIR_TEXT),
+    text2: z.string().min(LENGTH_MIN_PAIR_TEXT).max(LENGTH_MAX_PAIR_TEXT),
+    language1: z.string().min(LENGTH_MIN_LANGUAGE).max(LENGTH_MAX_LANGUAGE),
+    language2: z.string().min(LENGTH_MIN_LANGUAGE).max(LENGTH_MAX_LANGUAGE),
+    ipa1: z.string().min(LENGTH_MIN_IPA).max(LENGTH_MAX_IPA).optional(),
+    ipa2: z.string().min(LENGTH_MIN_IPA).max(LENGTH_MAX_IPA).optional(),
+    folderId: z.int()
+});
+export type ActionInputCreatePair = z.infer<typeof schemaActionInputCreatePair>;
+export const validateActionInputCreatePair = generateValidator(schemaActionInputCreatePair);
+
+export const schemaActionInputUpdatePairById = z.object({
+    text1: z.string().min(LENGTH_MIN_PAIR_TEXT).max(LENGTH_MAX_PAIR_TEXT).optional(),
+    text2: z.string().min(LENGTH_MIN_PAIR_TEXT).max(LENGTH_MAX_PAIR_TEXT).optional(),
+    language1: z.string().min(LENGTH_MIN_LANGUAGE).max(LENGTH_MAX_LANGUAGE).optional(),
+    language2: z.string().min(LENGTH_MIN_LANGUAGE).max(LENGTH_MAX_LANGUAGE).optional(),
+    ipa1: z.string().min(LENGTH_MIN_IPA).max(LENGTH_MAX_IPA).optional(),
+    ipa2: z.string().min(LENGTH_MIN_IPA).max(LENGTH_MAX_IPA).optional(),
+    folderId: z.int().optional()
+});
+export type ActionInputUpdatePairById = z.infer<typeof schemaActionInputUpdatePairById>;
+export const validateActionInputUpdatePairById = generateValidator(schemaActionInputUpdatePairById);
+
+export type ActionOutputGetFoldersWithTotalPairsByUserId = {
+    message: string,
+    success: boolean,
+    data?: TSharedFolderWithTotalPairs[];
+};

src/modules/folder/folder-repository-dto.ts

@@ -0,0 +1,23 @@
+export interface RepoInputCreateFolder {
+  name: string;
+  userId: string;
+}
+
+export interface RepoInputCreatePair {
+  text1: string;
+  text2: string;
+  language1: string;
+  language2: string;
+  ipa1?: string;
+  ipa2?: string;
+  folderId: number;
+}
+
+export interface RepoInputUpdatePair {
+  text1?: string;
+  text2?: string;
+  language1?: string;
+  language2?: string;
+  ipa1?: string;
+  ipa2?: string;
+}

src/modules/folder/folder-repository.ts

@@ -0,0 +1,120 @@
+import prisma from "@/lib/db";
+import { RepoInputCreateFolder, RepoInputCreatePair, RepoInputUpdatePair } from "./folder-repository-dto";
+
+export async function repoCreatePair(data: RepoInputCreatePair) {
+    return (await prisma.pair.create({
+        data: data,
+    })).id;
+}
+
+export async function repoDeletePairById(id: number) {
+    await prisma.pair.delete({
+        where: {
+            id: id,
+        },
+    });
+}
+
+export async function repoUpdatePairById(
+    id: number,
+    data: RepoInputUpdatePair,
+) {
+    await prisma.pair.update({
+        where: {
+            id: id,
+        },
+        data: data,
+    });
+}
+
+export async function repoGetPairCountByFolderId(folderId: number) {
+    return prisma.pair.count({
+        where: {
+            folderId: folderId,
+        },
+    });
+}
+
+export async function repoGetPairsByFolderId(folderId: number) {
+    return (await prisma.pair.findMany({
+        where: {
+            folderId: folderId,
+        },
+    })).map(pair => {
+        return {
+            text1:pair.text1,
+            text2: pair.text2,
+            language1: pair.language1,
+            language2: pair.language2,
+            ipa1: pair.ipa1,
+            ipa2: pair.ipa2,
+            id: pair.id,
+            folderId: pair.folderId
+        }
+    });
+}
+
+export async function repoGetFoldersByUserId(userId: string) {
+  return (await prisma.folder.findMany({
+    where: {
+      userId: userId,
+    },
+  }))?.map(v => {
+    return {
+      id: v.id,
+      name: v.name,
+      userId: v.userId
+    };
+  });
+}
+
+export async function repoRenameFolderById(id: number, newName: string) {
+  await prisma.folder.update({
+    where: {
+      id: id,
+    },
+    data: {
+      name: newName,
+    },
+  });
+}
+
+export async function repoGetFoldersWithTotalPairsByUserId(userId: string) {
+  const folders = await prisma.folder.findMany({
+    where: { userId },
+    include: {
+      _count: {
+        select: { pairs: true },
+      },
+    },
+  });
+  return folders.map(folder => ({
+    id: folder.id,
+    name: folder.name,
+    userId: folder.userId,
+    total: folder._count?.pairs ?? 0,
+  }));
+}
+
+export async function repoCreateFolder(folder: RepoInputCreateFolder) {
+  await prisma.folder.create({
+    data: folder,
+  });
+}
+
+export async function repoDeleteFolderById(id: number) {
+  await prisma.folder.delete({
+    where: {
+      id: id,
+    },
+  });
+}
+
+export async function repoGetUserIdByFolderId(id: number) {
+  const folder = await prisma.folder.findUnique({
+    where: {
+      id: id,
+    },
+  });
+  return folder?.userId;
+}

src/modules/folder/folder-service.ts

@@ -1,68 +0,0 @@
-import { CreateFolderInput, UpdateFolderInput } from "../translator/translator-dto";
-import prisma from "@/lib/db";
-
-export async function getFoldersByUserId(userId: string) {
-  return prisma.folder.findMany({
-    where: {
-      userId: userId,
-    },
-  });
-}
-
-export async function renameFolderById(id: number, newName: string) {
-  return prisma.folder.update({
-    where: {
-      id: id,
-    },
-    data: {
-      name: newName,
-    },
-  });
-}
-
-export async function getFoldersWithTotalPairsByUserId(userId: string) {
-  const folders = await prisma.folder.findMany({
-    where: { userId },
-    include: {
-      _count: {
-        select: { pairs: true },
-      },
-    },
-  });
-  return folders.map(folder => ({
-    ...folder,
-    total: folder._count?.pairs ?? 0,
-  }));
-}
-
-export async function createFolder(folder: CreateFolderInput) {
-  return prisma.folder.create({
-    data: folder,
-  });
-}
-
-export async function deleteFolderById(id: number) {
-  return prisma.folder.delete({
-    where: {
-      id: id,
-    },
-  });
-}
-
-export async function updateFolderById(id: number, data: UpdateFolderInput) {
-  return prisma.folder.update({
-    where: {
-      id: id,
-    },
-    data: data,
-  });
-}
-
-export async function getUserIdByFolderId(id: number) {
-  const folder = await prisma.folder.findUnique({
-    where: {
-      id: id,
-    },
-  });
-  return folder?.userId;
-}

src/modules/folder/index.ts

@@ -0,0 +1,2 @@
+export * from './folder-aciton';
+export * from './folder-action-dto';