sonamu 0.5.7 → 0.6.0

package/src/syncer/entity-operations.ts

@@ -0,0 +1,68 @@
+import { rm } from "fs/promises";
+import { exists } from "../utils/fs-utils";
+import chalk from "chalk";
+import { EntityManager } from "../entity/entity-manager";
+import { TemplateOptions } from "../types/types";
+import { BadRequestException } from "../exceptions/so-exceptions";
+import { Sonamu } from "../api/sonamu";
+import { generateTemplate } from "./code-generator";
+
+/**
+ * 새로운 엔티티를 생성합니다.
+ * entityId는 반드시 CamelCase 형식이어야 합니다.
+ */
+export async function createEntity(
+  form: Omit<TemplateOptions["entity"], "title"> & { title?: string }
+) {
+  if (!/^[A-Z][a-zA-Z0-9]*$/.test(form.entityId)) {
+    throw new BadRequestException("entityId는 CamelCase 형식이어야 합니다.");
+  }
+
+  await generateTemplate("entity", form);
+
+  // reload entities
+  await EntityManager.reload();
+}
+
+/**
+ * 엔티티를 삭제합니다.
+ * parentId가 있는 서브 엔티티의 경우 entity.json만 삭제하고,
+ * 루트 엔티티의 경우 디렉토리 전체와 타겟 디렉토리를 삭제합니다.
+ */
+export async function delEntity(
+  entityId: string
+): Promise<{ delPaths: string[] }> {
+  const entity = EntityManager.get(entityId);
+
+  const delPaths = (() => {
+    if (entity.parentId) {
+      return [
+        `${Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`,
+      ];
+    } else {
+      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(),
+      ];
+    }
+  })(); // iife
+
+  for await (const delPath of delPaths) {
+    if (await exists(delPath)) {
+      console.log(chalk.red(`DELETE ${delPath}`));
+      await rm(delPath, { recursive: true, force: true });
+    } else {
+      console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
+    }
+  }
+
+  // reload entities
+  await EntityManager.reload();
+
+  return { delPaths };
+}

package/src/syncer/file-patterns.ts

@@ -0,0 +1,56 @@
+import path from "path";
+import { Sonamu } from "../api/sonamu";
+import { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
+
+export type FileType =
+  | "model"
+  | "types"
+  | "functions"
+  | "generated"
+  | "entity"
+  | "frame"
+  | "config";
+
+export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = {
+  [key in FileType]: T;
+};
+
+/**
+ * Syncer가 관심 가지고 지켜보는 파일들입니다.
+ * 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.
+ * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.
+ *
+ * **경로 형식**: API 상대 경로 (src/로 시작)
+ * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
+ */
+export const checksumPatternGroup: GlobPattern<ApiRelativePath> = {
+  entity: "src/application/**/*.entity.json",
+  types: "src/application/**/*.types.ts",
+  generated: "src/application/sonamu.generated.ts",
+  model: "src/application/**/*.model.ts",
+  frame: "src/application/**/*.frame.ts",
+  functions: "src/application/**/*.functions.ts",
+  config: "sonamu.config.ts",
+};
+
+/**
+ * API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
+ *
+ * **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
+ *
+ * **사용처**: checksum.ts에서 실제 파일을 찾을 때
+ *
+ * @returns 절대 경로 기반 Glob 패턴 맵
+ *
+ * @example
+ * // 입력: { entity: "src/application/**\/*.entity.json" }
+ * // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
+ */
+export function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePath> {
+  return Object.fromEntries(
+    Object.entries(checksumPatternGroup).map(([key, value]) => [
+      key,
+      path.join(Sonamu.apiRootPath, value), // API 상대 경로 → 절대 경로
+    ])
+  ) as GlobPattern<AbsolutePath>;
+}

package/src/syncer/index.ts

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

package/src/syncer/module-loader.ts

@@ -0,0 +1,125 @@
+import path from "path";
+import { globAsync } from "../utils/async-utils";
+import { importMembers } from "../utils/esm-utils";
+import { z } from "zod";
+import { Sonamu } from "../api/sonamu";
+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[];
+  parameters: ApiParam[];
+  returnType: ApiParamType;
+  modelName: string;
+  methodName: string;
+  path: string;
+  options: ApiDecoratorOptions;
+}[];
+
+export type LoadedTypes = { [typeName: string]: z.ZodObject<any> };
+
+export type LoadedModels = {
+  [modelName: string]: BaseModelClass | BaseFrameClass;
+};
+
+/**
+ * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.
+ * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.
+ * 따라서 loadModels()를 먼저 호출해야 합니다.
+ */
+export async function loadApis(): Promise<LoadedApis> {
+  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,
+  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.
+  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.
+  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!
+  const modelPathsPattern = path.join(
+    Sonamu.apiRootPath,
+    "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.`)
+  // );
+
+  return apis;
+}
+
+/**
+ * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.
+ */
+export async function loadModels(): Promise<LoadedModels> {
+  const modelPathsPattern = path.join(
+    Sonamu.apiRootPath,
+    runtimePath("src/application/**/*.{model,frame}.ts")
+  );
+  const modelPaths = await globAsync(modelPathsPattern);
+
+  const models: LoadedModels = {};
+  let count = 0;
+  for (const filePath of modelPaths) {
+    const importedMembers = await importMembers<
+      BaseModelClass | BaseFrameClass
+    >(filePath);
+
+    for (const { name, value } of importedMembers) {
+      if (name.endsWith("Model") || name.endsWith("Frame")) {
+        models[name] = value;
+      }
+    }
+    count++;
+  }
+  // console.log(
+  //   chalk.gray(
+  //     `[Loading] Loaded model/frame instances from ${runtimePath("*.{model,frame}.ts")} files: ${count} files.`
+  //   )
+  // );
+
+  return models;
+}
+
+/**
+ * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.
+ */
+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")
+    ),
+  ];
+  const typePaths = (
+    await Promise.all(typePathsPatterns.map(globAsync))
+  ).flat();
+
+  const types: LoadedTypes = {};
+  let count = 0;
+  for (const filePath of typePaths) {
+    const importedMembers = await importMembers<z.ZodObject<any>>(filePath);
+    for (const { name, value } of importedMembers) {
+      if (value instanceof z.ZodObject) {
+        types[name] = value;
+      }
+    }
+    count++;
+  }
+  // console.log(
+  //   chalk.gray(
+  //     `[Loading] Loaded zod types from ${runtimePath("*.types.ts")} and ${runtimePath("*.generated.ts")} files: ${count} files.`
+  //   )
+  // );
+
+  return types;
+}