sonamu 0.5.6 → 0.6.0

package/src/syncer/checksum.ts

@@ -0,0 +1,152 @@
+import path from "path";
+import { globAsync } from "../utils/async-utils";
+import { createReadStream, PathLike } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { exists } from "../utils/fs-utils";
+
+import crypto from "crypto";
+import equal from "fast-deep-equal";
+import * as _ from "lodash-es";
+import { Sonamu } from "../api/sonamu";
+import {
+  AbsolutePath,
+  ApiRelativePath,
+} from "../utils/path-utils";
+import { getChecksumPatternGroupInAbsolutePath } from "./file-patterns";
+
+type PathAndChecksum = {
+  path: AbsolutePath;
+  checksum: string;
+};
+
+/**
+ * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.
+ * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: "/src/application/user/user.model.ts"
+ */
+export async function findChangedFilesUsingChecksums(): Promise<
+  AbsolutePath[]
+> {
+  const calculatedChecksums = await getCurrentChecksums();
+  const savedChecksums = await getPreviousChecksums();
+
+  const isSame = equal(calculatedChecksums, savedChecksums);
+  if (isSame) {
+    return [];
+  }
+
+  const diff = _.differenceWith(calculatedChecksums, savedChecksums, _.isEqual);
+
+  return diff.map((r) => r.path);
+}
+
+/**
+ * 체크섬을 갱신합니다.
+ * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.
+ */
+export async function renewChecksums(): Promise<void> {
+  const calculatedChecksums = await getCurrentChecksums();
+  const savedChecksums = await getPreviousChecksums();
+
+  const isSame = equal(calculatedChecksums, savedChecksums);
+  if (isSame) {
+    return;
+  }
+
+  await saveChecksums(calculatedChecksums);
+}
+
+/**
+ * 두 파일의 내용이 같은지 체크섬으로 비교합니다.
+ * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.
+ * @param one 파일 경로
+ * @param two 파일 경로
+ * @returns boolean
+ */
+export async function areFilesSame(
+  one: PathLike,
+  two: PathLike
+): Promise<boolean> {
+  if (!(await exists(one)) || !(await exists(two))) {
+    return false;
+  }
+
+  const oneChecksum = await getChecksumOfFile(one);
+  const twoChecksum = await getChecksumOfFile(two);
+
+  return oneChecksum === twoChecksum;
+}
+
+async function getCurrentChecksums(): Promise<PathAndChecksum[]> {
+  const filePaths = (
+    await Promise.all(
+      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(
+        async ([_fileType, pattern]) => {
+          return globAsync(pattern) as Promise<AbsolutePath[]>;
+        }
+      )
+    )
+  )
+    .flat()
+    .sort();
+
+  const fileChecksums = await Promise.all(
+    filePaths.map(async (filePath) => {
+      return {
+        path: filePath,
+        checksum: await getChecksumOfFile(filePath),
+      };
+    })
+  );
+
+  return fileChecksums;
+}
+
+async function getPreviousChecksums(): Promise<PathAndChecksum[]> {
+  const checksumFilePath = getChecksumFilePath();
+  if (!(await exists(checksumFilePath))) {
+    return [];
+  }
+
+  const previousChecksums = JSON.parse(
+    await readFile(checksumFilePath, "utf-8")
+  ).map((r: { path: ApiRelativePath; checksum: string }) => ({
+    path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로
+    checksum: r.checksum,
+  })) as PathAndChecksum[];
+  return previousChecksums;
+}
+
+function getChecksumFilePath(): AbsolutePath {
+  return path.join(Sonamu.apiRootPath, "sonamu.lock") as AbsolutePath;
+}
+
+async function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {
+  const checksumFilePath = getChecksumFilePath();
+  await writeFile(
+    checksumFilePath,
+    JSON.stringify(
+      checksums.map((r) => ({
+        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로
+        checksum: r.checksum,
+      })),
+      null,
+      2
+    ),
+    "utf-8"
+  );
+  console.log("checksum saved", checksumFilePath);
+}
+
+async function getChecksumOfFile(filePath: PathLike): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    const input = createReadStream(filePath);
+    input.on("error", reject);
+    input.on("data", function (chunk: any) {
+      hash.update(chunk);
+    });
+    input.on("close", function () {
+      resolve(hash.digest("hex"));
+    });
+  });
+}

package/src/syncer/code-generator.ts

@@ -0,0 +1,202 @@
+import path from "path";
+import { Sonamu } from "../api/sonamu";
+import { AlreadyProcessedException } from "../exceptions/so-exceptions";
+import {
+  GenerateOptions,
+  PathAndCode,
+  TemplateKey,
+  TemplateOptions,
+} from "../types/types";
+import { everyAsync, filterAsync } from "../utils/async-utils";
+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";
+
+/**
+ * 템플릿을 렌더링하고 파일로 생성합니다.
+ * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
+ * @param key - 템플릿 키 (예: "entity", "model", "service" 등)
+ * @param templateOptions - 템플릿 렌더링에 필요한 옵션
+ * @param _generateOptions - 생성 옵션 (overwrite 여부)
+ * @returns 생성된 파일 경로 배열
+ */
+export async function generateTemplate(
+  key: TemplateKey,
+  templateOptions: any,
+  _generateOptions?: GenerateOptions
+): Promise<AbsolutePath[]> {
+  const generateOptions = {
+    overwrite: false,
+    ..._generateOptions,
+  };
+
+  // 키 children
+  const keys: TemplateKey[] = [key];
+
+  // 템플릿 렌더
+  const pathAndCodes = (
+    await Promise.all(
+      keys.map(async (key) => {
+        return await renderTemplate(key, templateOptions);
+      })
+    )
+  ).flat();
+
+  const filteredPathAndCodes: PathAndCode[] = await (async () => {
+    if (generateOptions.overwrite === true) {
+      return pathAndCodes;
+    } else {
+      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))
+        );
+      });
+    }
+  })();
+  
+  if (filteredPathAndCodes.length === 0) {
+    throw new AlreadyProcessedException("이미 경로에 모든 파일이 존재합니다.");
+  }
+
+  return (await Promise.all(
+    filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode))
+  )).flat();
+}
+
+/**
+ * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.
+ * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.
+ * @param key - 템플릿 키
+ * @param options - 템플릿 렌더링 옵션
+ * @returns 경로와 코드 쌍의 배열
+ */
+export async function renderTemplate<T extends keyof TemplateOptions>(
+  key: T,
+  options: TemplateOptions[T]
+): Promise<PathAndCode[]> {
+  const template = Template.find(key);
+
+  const rendered = await template.render(options);
+  const resolved = await resolveRenderedTemplate(key, rendered);
+
+  let preTemplateResolved: PathAndCode[] = [];
+  if (rendered.preTemplates) {
+    preTemplateResolved = (
+      await Promise.all(
+        rendered.preTemplates.map(({ key, options }) => {
+          return renderTemplate(key, options);
+        })
+      )
+    ).flat();
+  }
+
+  return [resolved, ...preTemplateResolved];
+}
+
+async function resolveRenderedTemplate(
+  key: TemplateKey,
+  result: RenderedTemplate
+): Promise<PathAndCode> {
+  const { target, path: filePath, body, importKeys, customHeaders } = result;
+
+  // import 할 대상의 대상 path 추출
+  const importDefs = importKeys
+    .reduce(
+      (r, importKey) => {
+        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]
+          );
+        }
+
+        // 같은 파일에서 import 하는 경우 keys 로 나열 처리
+        const existsOne = r.find((importDef) => importDef.from === importPath);
+        if (existsOne) {
+          existsOne.keys = _.uniq(existsOne.keys.concat(importKey));
+        } else {
+          r.push({
+            keys: [importKey],
+            from: importPath,
+          });
+        }
+        return r;
+      },
+      [] as {
+        keys: string[];
+        from: string;
+      }[]
+    )
+    // 셀프 참조 방지
+    .filter(
+      (importDef) =>
+        filePath.endsWith(importDef.from.replace("./", "") + ".ts") === false
+    );
+
+  // 커스텀 헤더 포함하여 헤더 생성
+  const header = [
+    ...(customHeaders ?? []),
+    ...importDefs.map(
+      (importDef) =>
+        `import { ${importDef.keys.join(", ")} } from '${importDef.from}'`
+    ),
+  ].join("\n");
+
+  const formatted = await (async () => {
+    if (key === "generated_http") {
+      return [header, body].join("\n\n");
+    } else {
+      return prettier.format([header, body].join("\n\n"), {
+        parser: key === "entity" ? "json" : "typescript",
+      });
+    }
+  })();
+
+  return {
+    path: target + "/" + filePath,
+    code: formatted,
+  };
+}
+
+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[]
+  );
+  return await Promise.all(
+    dstFilePaths.map(async (dstFilePath) => {
+      const dir = path.dirname(dstFilePath);
+      if (!(await exists(dir))) {
+        await mkdir(dir, { recursive: true });
+      }
+      await writeFile(dstFilePath, pathAndCode.code);
+      console.log(
+        chalk.bold("Generated: ") +
+          chalk.blue(`${dstFilePath.replace(appRootPath + "/", "")}`)
+      );
+      return dstFilePath;
+    })
+  );
+}

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;
+}