sonamu 0.6.0 → 0.7.0

package/src/syncer/code-generator.ts

@@ -1,23 +1,20 @@
+import chalk from "chalk";
+import { mkdir, writeFile } from "fs/promises";
 import path from "path";
+import { unique } from "radashi";
 import { Sonamu } from "../api/sonamu";
+import { EntityManager } from "../entity/entity-manager";
 import { AlreadyProcessedException } from "../exceptions/so-exceptions";
-import {
-  GenerateOptions,
-  PathAndCode,
-  TemplateKey,
-  TemplateOptions,
-} from "../types/types";
+import { Naite } from "../naite/naite";
+import type { RenderedTemplate } from "../template/template";
+import { TemplateManager } from "../template/template-manager";
+import type { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from "../types/types";
 import { everyAsync, filterAsync } from "../utils/async-utils";
+import { isTest } from "../utils/controller";
+import { formatCode } from "../utils/formatter";
 import { exists } from "../utils/fs-utils";
-import chalk from "chalk";
-import { mkdir, writeFile } from "fs/promises";
-import * as _ from "lodash-es";
-import { Template } from "../template/template";
-import { RenderedTemplate } from "../template/template";
-import { EntityManager } from "../entity/entity-manager";
 import { wrapIf } from "../utils/lodash-able";
-import prettier from "prettier";
-import { AbsolutePath } from "../utils/path-utils";
+import type { AbsolutePath } from "../utils/path-utils";
 
 /**
  * 템플릿을 렌더링하고 파일로 생성합니다.
@@ -27,15 +24,16 @@ import { AbsolutePath } from "../utils/path-utils";
  * @param _generateOptions - 생성 옵션 (overwrite 여부)
  * @returns 생성된 파일 경로 배열
  */
-export async function generateTemplate(
-  key: TemplateKey,
-  templateOptions: any,
-  _generateOptions?: GenerateOptions
+export async function generateTemplate<T extends TemplateKey>(
+  key: T,
+  templateOptions: TemplateOptions[T],
+  _generateOptions?: GenerateOptions,
 ): Promise<AbsolutePath[]> {
   const generateOptions = {
     overwrite: false,
     ..._generateOptions,
   };
+  Naite.t("generateTemplate", { key, templateOptions, generateOptions });
 
   // 키 children
   const keys: TemplateKey[] = [key];
@@ -45,7 +43,7 @@ export async function generateTemplate(
     await Promise.all(
       keys.map(async (key) => {
         return await renderTemplate(key, templateOptions);
-      })
+      }),
     )
   ).flat();
 
@@ -56,24 +54,21 @@ export async function generateTemplate(
       return await filterAsync(pathAndCodes, async (pathAndCode) => {
         const { targets } = Sonamu.config.sync;
         const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
-        const dstFilePaths = targets.map((target) =>
-          filePath.replace("/:target/", `/${target}/`)
-        );
-        return await everyAsync(
-          dstFilePaths,
-          async (dstPath) => !(await exists(dstPath))
-        );
+        const dstFilePaths = targets.map((target) => filePath.replace("/:target/", `/${target}/`));
+        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));
       });
     }
   })();
-  
+
   if (filteredPathAndCodes.length === 0) {
     throw new AlreadyProcessedException("이미 경로에 모든 파일이 존재합니다.");
   }
 
-  return (await Promise.all(
-    filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode))
-  )).flat();
+  return (
+    await Promise.all(
+      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),
+    )
+  ).flat();
 }
 
 /**
@@ -85,9 +80,11 @@ export async function generateTemplate(
  */
 export async function renderTemplate<T extends keyof TemplateOptions>(
   key: T,
-  options: TemplateOptions[T]
+  options: TemplateOptions[T],
 ): Promise<PathAndCode[]> {
-  const template = Template.find(key);
+  Naite.t("renderTemplate", { key, options });
+
+  const template = TemplateManager.get(key);
 
   const rendered = await template.render(options);
   const resolved = await resolveRenderedTemplate(key, rendered);
@@ -98,7 +95,7 @@ export async function renderTemplate<T extends keyof TemplateOptions>(
       await Promise.all(
         rendered.preTemplates.map(({ key, options }) => {
           return renderTemplate(key, options);
-        })
+        }),
       )
     ).flat();
   }
@@ -108,8 +105,10 @@ export async function renderTemplate<T extends keyof TemplateOptions>(
 
 async function resolveRenderedTemplate(
   key: TemplateKey,
-  result: RenderedTemplate
+  result: RenderedTemplate,
 ): Promise<PathAndCode> {
+  Naite.t(`resolveRenderedTemplate${key}`, { key, result });
+
   const { target, path: filePath, body, importKeys, customHeaders } = result;
 
   // import 할 대상의 대상 path 추출
@@ -119,16 +118,16 @@ async function resolveRenderedTemplate(
         const modulePath = EntityManager.getModulePath(importKey);
         let importPath = modulePath;
         if (modulePath.includes("/") || modulePath.includes(".")) {
-          importPath = wrapIf(
-            path.relative(path.dirname(filePath), modulePath),
-            (p) => [p.startsWith(".") === false, "./" + p]
-          );
+          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [
+            p.startsWith(".") === false,
+            `./${p}`,
+          ]);
         }
 
         // 같은 파일에서 import 하는 경우 keys 로 나열 처리
         const existsOne = r.find((importDef) => importDef.from === importPath);
         if (existsOne) {
-          existsOne.keys = _.uniq(existsOne.keys.concat(importKey));
+          existsOne.keys = unique(existsOne.keys.concat(importKey));
         } else {
           r.push({
             keys: [importKey],
@@ -140,20 +139,16 @@ async function resolveRenderedTemplate(
       [] as {
         keys: string[];
         from: string;
-      }[]
+      }[],
     )
     // 셀프 참조 방지
-    .filter(
-      (importDef) =>
-        filePath.endsWith(importDef.from.replace("./", "") + ".ts") === false
-    );
+    .filter((importDef) => filePath.endsWith(`${importDef.from.replace("./", "")}.ts`) === false);
 
   // 커스텀 헤더 포함하여 헤더 생성
   const header = [
     ...(customHeaders ?? []),
     ...importDefs.map(
-      (importDef) =>
-        `import { ${importDef.keys.join(", ")} } from '${importDef.from}'`
+      (importDef) => `import { ${importDef.keys.join(", ")} } from '${importDef.from}'`,
     ),
   ].join("\n");
 
@@ -161,29 +156,30 @@ async function resolveRenderedTemplate(
     if (key === "generated_http") {
       return [header, body].join("\n\n");
     } else {
-      return prettier.format([header, body].join("\n\n"), {
-        parser: key === "entity" ? "json" : "typescript",
-      });
+      Naite.t("resolveRenderedTemplate:beforeFormat", { key, header, body });
+      const formatted = formatCode(
+        [header, body].join("\n\n"),
+        key === "entity" ? "json" : "typescript",
+        `${Sonamu.appRootPath}/${filePath}`,
+      );
+      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);
+      return formatted;
     }
   })();
 
   return {
-    path: target + "/" + filePath,
+    path: `${target}/${filePath}`,
     code: formatted,
   };
 }
 
-async function writeCodeToPathEachTarget(
-  pathAndCode: PathAndCode
-): Promise<AbsolutePath[]> {
+async function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {
   const { targets } = Sonamu.config.sync;
   const { appRootPath } = Sonamu;
   const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;
 
-  const dstFilePaths = _.uniq(
-    targets.map((target) =>
-      filePath.replace("/:target/", `/${target}/`)
-    ) as AbsolutePath[]
+  const dstFilePaths = unique(
+    targets.map((target) => filePath.replace("/:target/", `/${target}/`)) as AbsolutePath[],
   );
   return await Promise.all(
     dstFilePaths.map(async (dstFilePath) => {
@@ -192,11 +188,11 @@ async function writeCodeToPathEachTarget(
         await mkdir(dir, { recursive: true });
       }
       await writeFile(dstFilePath, pathAndCode.code);
-      console.log(
-        chalk.bold("Generated: ") +
-          chalk.blue(`${dstFilePath.replace(appRootPath + "/", "")}`)
-      );
+      !isTest() &&
+        console.log(
+          chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, "")}`),
+        );
       return dstFilePath;
-    })
+    }),
   );
 }

package/src/syncer/entity-operations.ts

@@ -1,10 +1,11 @@
-import { rm } from "fs/promises";
-import { exists } from "../utils/fs-utils";
 import chalk from "chalk";
+import { rm } from "fs/promises";
+import { Sonamu } from "../api/sonamu";
 import { EntityManager } from "../entity/entity-manager";
-import { TemplateOptions } from "../types/types";
 import { BadRequestException } from "../exceptions/so-exceptions";
-import { Sonamu } from "../api/sonamu";
+import type { TemplateOptions } from "../types/types";
+import { isTest } from "../utils/controller";
+import { exists } from "../utils/fs-utils";
 import { generateTemplate } from "./code-generator";
 
 /**
@@ -12,7 +13,7 @@ import { generateTemplate } from "./code-generator";
  * entityId는 반드시 CamelCase 형식이어야 합니다.
  */
 export async function createEntity(
-  form: Omit<TemplateOptions["entity"], "title"> & { title?: string }
+  form: Omit<TemplateOptions["entity"], "title"> & { title: string },
 ) {
   if (!/^[A-Z][a-zA-Z0-9]*$/.test(form.entityId)) {
     throw new BadRequestException("entityId는 CamelCase 형식이어야 합니다.");
@@ -29,9 +30,7 @@ export async function createEntity(
  * parentId가 있는 서브 엔티티의 경우 entity.json만 삭제하고,
  * 루트 엔티티의 경우 디렉토리 전체와 타겟 디렉토리를 삭제합니다.
  */
-export async function delEntity(
-  entityId: string
-): Promise<{ delPaths: string[] }> {
+export async function delEntity(entityId: string): Promise<{ delPaths: string[] }> {
   const entity = EntityManager.get(entityId);
 
   const delPaths = (() => {
@@ -43,21 +42,19 @@ export async function delEntity(
       return [
         `${Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
         `${Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
-        ...Sonamu.config.sync.targets
-          .map((target) => [
-            `${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`,
-          ])
-          .flat(),
+        ...Sonamu.config.sync.targets.flatMap((target) => [
+          `${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`,
+        ]),
       ];
     }
   })(); // iife
 
   for await (const delPath of delPaths) {
     if (await exists(delPath)) {
-      console.log(chalk.red(`DELETE ${delPath}`));
+      !isTest() && console.log(chalk.red(`DELETE ${delPath}`));
       await rm(delPath, { recursive: true, force: true });
     } else {
-      console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
+      !isTest() && console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
     }
   }
 

package/src/syncer/file-patterns.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import { Sonamu } from "../api/sonamu";
-import { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
+import type { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
 
 export type FileType =
   | "model"
@@ -51,6 +51,6 @@ export function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePat
     Object.entries(checksumPatternGroup).map(([key, value]) => [
       key,
       path.join(Sonamu.apiRootPath, value), // API 상대 경로 → 절대 경로
-    ])
+    ]),
   ) as GlobPattern<AbsolutePath>;
 }

package/src/syncer/index.ts

@@ -1,7 +1,7 @@
-export * from "./syncer";
+export * from "./api-parser";
+export * from "./checksum";
 export * from "./code-generator";
-export * from "./module-loader";
 export * from "./entity-operations";
 export * from "./file-patterns";
-export * from "./checksum";
-export * from "./api-parser";
+export * from "./module-loader";
+export * from "./syncer";

package/src/syncer/module-loader.ts

@@ -1,14 +1,14 @@
 import path from "path";
-import { globAsync } from "../utils/async-utils";
-import { importMembers } from "../utils/esm-utils";
 import { z } from "zod";
+import type { BaseFrameClass } from "../api/base-frame";
+import type { ApiDecoratorOptions } from "../api/decorators";
 import { Sonamu } from "../api/sonamu";
+import type { BaseModelClass } from "../database/base-model";
+import type { ApiParam, ApiParamType } from "../types/types";
+import { globAsync } from "../utils/async-utils";
+import { importMembers } from "../utils/esm-utils";
+import { type AbsolutePath, runtimePath } from "../utils/path-utils";
 import { readApisFromFile } from "./api-parser";
-import { BaseFrameClass } from "../api/base-frame";
-import { BaseModelClass } from "../database/base-model";
-import { AbsolutePath, runtimePath } from "../utils/path-utils";
-import { ApiParam, ApiParamType } from "../types/types";
-import { ApiDecoratorOptions } from "../api/decorators";
 
 export type LoadedApis = {
   typeParameters: ApiParamType.TypeParam[];
@@ -20,6 +20,7 @@ export type LoadedApis = {
   options: ApiDecoratorOptions;
 }[];
 
+// biome-ignore lint/suspicious/noExplicitAny: zod 스키마를 로드할 때 사용하는 타입
 export type LoadedTypes = { [typeName: string]: z.ZodObject<any> };
 
 export type LoadedModels = {
@@ -38,21 +39,29 @@ export async function loadApis(): Promise<LoadedApis> {
   // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!
   const modelPathsPattern = path.join(
     Sonamu.apiRootPath,
-    "src/application/**/*.{model,frame}.ts" // !! runtimePath 안 씀 주의 !!
+    "src/application/**/*.{model,frame}.ts", // !! runtimePath 안 씀 주의 !!
   );
   const modelPaths = (await globAsync(modelPathsPattern)) as AbsolutePath[];
 
   const apis: LoadedApis = [];
-  let count = 0;
   for (const filePath of modelPaths) {
     const parsedApis = await readApisFromFile(filePath);
     apis.push(...parsedApis);
-    count++;
   }
   // console.log(
   //   chalk.gray(`[Loading] Loaded APIs from "*.model.ts" files: ${count} files.`)
   // );
 
+  for (const api of apis) {
+    if (api.path === "") {
+      // api의 경로(path)가 "텅 비어있음"인 상태입니다.
+      // 이는 @api와 함께 사용해야 하는 데코레이터(가령 @upload)가 @api 없이 붙은 상황입니다.
+      throw new Error(
+        `API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`,
+      );
+    }
+  }
+
   return apis;
 }
 
@@ -62,23 +71,21 @@ export async function loadApis(): Promise<LoadedApis> {
 export async function loadModels(): Promise<LoadedModels> {
   const modelPathsPattern = path.join(
     Sonamu.apiRootPath,
-    runtimePath("src/application/**/*.{model,frame}.ts")
+    runtimePath("src/application/**/*.{model,frame}.ts"),
   );
   const modelPaths = await globAsync(modelPathsPattern);
 
   const models: LoadedModels = {};
-  let count = 0;
+  let _count = 0;
   for (const filePath of modelPaths) {
-    const importedMembers = await importMembers<
-      BaseModelClass | BaseFrameClass
-    >(filePath);
+    const importedMembers = await importMembers<BaseModelClass | BaseFrameClass>(filePath);
 
     for (const { name, value } of importedMembers) {
       if (name.endsWith("Model") || name.endsWith("Frame")) {
         models[name] = value;
       }
     }
-    count++;
+    _count++;
   }
   // console.log(
   //   chalk.gray(
@@ -95,25 +102,21 @@ export async function loadModels(): Promise<LoadedModels> {
 export async function loadTypes(): Promise<LoadedTypes> {
   const typePathsPatterns = [
     path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.types.ts")),
-    path.join(
-      Sonamu.apiRootPath,
-      runtimePath("src/application/**/*.generated.ts")
-    ),
+    path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.generated.ts")),
   ];
-  const typePaths = (
-    await Promise.all(typePathsPatterns.map(globAsync))
-  ).flat();
+  const typePaths = (await Promise.all(typePathsPatterns.map(globAsync))).flat();
 
   const types: LoadedTypes = {};
-  let count = 0;
+  let _count = 0;
   for (const filePath of typePaths) {
+    // biome-ignore lint/suspicious/noExplicitAny: zod 스키마를 로드할 때 사용하는 타입
     const importedMembers = await importMembers<z.ZodObject<any>>(filePath);
     for (const { name, value } of importedMembers) {
       if (value instanceof z.ZodObject) {
         types[name] = value;
       }
     }
-    count++;
+    _count++;
   }
   // console.log(
   //   chalk.gray(