sonamu 0.5.7 → 0.7.0

package/src/syncer/api-parser.ts

@@ -0,0 +1,282 @@
+import assert from "assert";
+import { readFile } from "fs/promises";
+import inflection from "inflection";
+import ts from "typescript";
+import { type ExtendedApi, registeredApis } from "../api/decorators";
+import { validateMethodName } from "../api/validator";
+import type { ApiParam, ApiParamType } from "../types/types";
+import type { AbsolutePath } from "../utils/path-utils";
+
+/**
+ * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
+ * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
+ * @param filePath - 파싱할 TypeScript 파일의 절대 경로
+ * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
+ */
+export async function readApisFromFile(filePath: AbsolutePath): Promise<ExtendedApi[]> {
+  if (!filePath.endsWith(".ts")) {
+    throw new Error(
+      `${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`,
+    );
+  }
+
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    (await readFile(filePath)).toString(),
+    ts.ScriptTarget.Latest,
+  );
+
+  const methods: Omit<ExtendedApi, "path" | "options">[] = [];
+  let modelName: string = "UnknownModel";
+  let methodName: string = "unknownMethod";
+  const visitor = (node: ts.Node) => {
+    if (ts.isClassDeclaration(node)) {
+      if (node.name && ts.isIdentifier(node.name)) {
+        modelName = node.name.escapedText.toString().replace(/Class$/, "");
+      }
+    }
+    if (ts.isMethodDeclaration(node)) {
+      if (ts.isIdentifier(node.name)) {
+        methodName = node.name.escapedText.toString();
+        validateMethodName(methodName);
+      }
+
+      const typeParameters: ApiParamType.TypeParam[] = (node.typeParameters ?? []).map(
+        (typeParam) => {
+          const tp = typeParam as ts.TypeParameterDeclaration;
+
+          return {
+            t: "type-param",
+            id: tp.name.escapedText.toString(),
+            constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined,
+          };
+        },
+      );
+      const parameters: ApiParam[] = node.parameters.map((paramDec, index) => {
+        const defaultDef = printNode(paramDec.initializer, sourceFile);
+
+        // 기본값이 있는 경우 paramDec.type가 undefined로 나옴
+
+        return resolveParamDec(
+          {
+            name: paramDec.name,
+            type: paramDec.type as ts.TypeNode,
+            optional: paramDec.questionToken !== undefined || paramDec.initializer !== undefined,
+            defaultDef,
+          },
+          index,
+        );
+      });
+      if (node.type === undefined) {
+        throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);
+      }
+      const returnType = resolveTypeNode(node.type);
+
+      methods.push({
+        modelName,
+        methodName,
+        typeParameters,
+        parameters,
+        returnType,
+      });
+    }
+    ts.forEachChild(node, visitor);
+  };
+  visitor(sourceFile);
+
+  if (methods.length === 0) {
+    return [];
+  }
+
+  // 현재 파일의 등록된 API 필터
+  const currentModelApis = registeredApis.filter((api) => {
+    return methods.find(
+      (method) => method.modelName === api.modelName && method.methodName === api.methodName,
+    );
+  });
+  if (currentModelApis.length === 0) {
+    // const p = path.join(tmpdir(), "sonamu-syncer-error.json");
+    // writeFileSync(p, JSON.stringify(registeredApis, null, 2));
+    // execSync(`open ${p}`);
+    throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);
+  }
+
+  // 등록된 API에 현재 메소드 타입 정보 확장
+  const extendedApis = currentModelApis.map((api) => {
+    const foundMethod = methods.find(
+      (method) => method.modelName === api.modelName && method.methodName === api.methodName,
+    );
+    if (!foundMethod) {
+      throw new Error(`API ${api.modelName}.${api.methodName} not found in ${filePath}`);
+    }
+    return {
+      ...api,
+      typeParameters: foundMethod?.typeParameters,
+      parameters: foundMethod?.parameters,
+      returnType: foundMethod?.returnType,
+    };
+  });
+  return extendedApis;
+}
+
+function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
+  switch (typeNode?.kind) {
+    case ts.SyntaxKind.AnyKeyword:
+      return "any";
+    case ts.SyntaxKind.UnknownKeyword:
+      return "unknown";
+    case ts.SyntaxKind.StringKeyword:
+      return "string";
+    case ts.SyntaxKind.NumberKeyword:
+      return "number";
+    case ts.SyntaxKind.BooleanKeyword:
+      return "boolean";
+    case ts.SyntaxKind.UndefinedKeyword:
+      return "undefined";
+    case ts.SyntaxKind.NullKeyword:
+      return "null";
+    case ts.SyntaxKind.VoidKeyword:
+      return "void";
+    case ts.SyntaxKind.LiteralType: {
+      const literal = (typeNode as ts.LiteralTypeNode).literal;
+      if (ts.isStringLiteral(literal)) {
+        return {
+          t: "string-literal",
+          value: literal.text,
+        };
+      } else if (ts.isNumericLiteral(literal)) {
+        return {
+          t: "numeric-literal",
+          value: Number(literal.text),
+        };
+      } else {
+        if (literal.kind === ts.SyntaxKind.NullKeyword) {
+          return "null";
+        } else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {
+          return "undefined";
+        } else if (literal.kind === ts.SyntaxKind.TrueKeyword) {
+          return "true";
+        } else if (literal.kind === ts.SyntaxKind.FalseKeyword) {
+          return "false";
+        }
+        throw new Error("알 수 없는 리터럴");
+      }
+    }
+    case ts.SyntaxKind.ArrayType: {
+      const arrNode = typeNode as ts.ArrayTypeNode;
+      return {
+        t: "array",
+        elementsType: resolveTypeNode(arrNode.elementType),
+      };
+    }
+    case ts.SyntaxKind.TypeLiteral: {
+      const literalNode = typeNode as ts.TypeLiteralNode;
+      return {
+        t: "object",
+        props: literalNode.members.map((member) => {
+          if (ts.isIndexSignatureDeclaration(member)) {
+            assert(member.parameters[0]);
+            const res = resolveParamDec({
+              name: member.parameters[0].name as ts.Identifier,
+              type: member.parameters[0].type as ts.TypeNode,
+            });
+
+            return resolveParamDec({
+              name: {
+                escapedText: `[${res.name}${res.optional ? "?" : ""}: ${res.type}]`,
+              } as ts.Identifier,
+              type: member.type as ts.TypeNode,
+            });
+          } else {
+            return resolveParamDec({
+              name: (member as ts.PropertySignature).name as ts.Identifier,
+              type: (member as ts.PropertySignature).type as ts.TypeNode,
+              optional: (member as ts.PropertySignature).questionToken !== undefined,
+            });
+          }
+        }),
+      };
+    }
+    case ts.SyntaxKind.TypeReference:
+      return {
+        t: "ref",
+        id: ((typeNode as ts.TypeReferenceNode).typeName as ts.Identifier).escapedText.toString(),
+        args: (typeNode as ts.TypeReferenceNode).typeArguments?.map((typeArg) =>
+          resolveTypeNode(typeArg),
+        ),
+      };
+    case ts.SyntaxKind.UnionType:
+      return {
+        t: "union",
+        types: (typeNode as ts.UnionTypeNode).types.map((type) => resolveTypeNode(type)),
+      };
+    case ts.SyntaxKind.IntersectionType:
+      return {
+        t: "intersection",
+        types: (typeNode as ts.IntersectionTypeNode).types.map((type) => resolveTypeNode(type)),
+      };
+    case ts.SyntaxKind.IndexedAccessType:
+      return {
+        t: "indexed-access",
+        object: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).objectType),
+        index: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).indexType),
+      };
+    case ts.SyntaxKind.TupleType:
+      if (ts.isTupleTypeNode(typeNode)) {
+        return {
+          t: "tuple-type",
+          elements: typeNode.elements.map((elem) => resolveTypeNode(elem)),
+        };
+      }
+      break;
+    case undefined:
+      throw new Error(`typeNode undefined`);
+  }
+
+  console.debug(typeNode);
+  throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);
+}
+
+function resolveParamDec(
+  paramDec: {
+    name: ts.BindingName;
+    type: ts.TypeNode;
+    optional?: boolean;
+    defaultDef?: string;
+  },
+  index: number = 0,
+): ApiParam {
+  const name = paramDec.name as ts.Identifier;
+  const type = resolveTypeNode(paramDec.type);
+
+  if (name === undefined) {
+    console.debug({ name, type, paramDec });
+  }
+
+  const result: ApiParam = {
+    name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,
+    type,
+    optional: paramDec.optional === true,
+    defaultDef: paramDec?.defaultDef,
+  };
+
+  // 구조분해할당의 경우 타입이름 사용
+  if (
+    ts.isObjectBindingPattern(name) &&
+    ts.isTypeReferenceNode(paramDec.type) &&
+    ts.isIdentifier(paramDec.type.typeName)
+  ) {
+    result.name = inflection.camelize(paramDec.type.typeName.text, true);
+  }
+
+  return result;
+}
+
+function printNode(node: ts.Node | undefined, sourceFile: ts.SourceFile): string | undefined {
+  if (node === undefined) {
+    return undefined;
+  }
+
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+}

package/src/syncer/checksum.ts

@@ -0,0 +1,140 @@
+import crypto, { type BinaryLike } from "crypto";
+import equal from "fast-deep-equal";
+import { createReadStream, type PathLike } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+import { isEqual } from "radashi";
+import { Sonamu } from "../api/sonamu";
+import { globAsync } from "../utils/async-utils";
+import { exists } from "../utils/fs-utils";
+import type { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
+import { differenceWith } from "../utils/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 [];
+  }
+
+  return differenceWith(calculatedChecksums, savedChecksums, isEqual).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", (chunk: BinaryLike) => {
+      hash.update(chunk);
+    });
+    input.on("close", () => {
+      resolve(hash.digest("hex"));
+    });
+  });
+}

package/src/syncer/code-generator.ts

@@ -0,0 +1,198 @@
+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 { 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 { wrapIf } from "../utils/lodash-able";
+import type { AbsolutePath } from "../utils/path-utils";
+
+/**
+ * 템플릿을 렌더링하고 파일로 생성합니다.
+ * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
+ * @param key - 템플릿 키 (예: "entity", "model", "service" 등)
+ * @param templateOptions - 템플릿 렌더링에 필요한 옵션
+ * @param _generateOptions - 생성 옵션 (overwrite 여부)
+ * @returns 생성된 파일 경로 배열
+ */
+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];
+
+  // 템플릿 렌더
+  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[]> {
+  Naite.t("renderTemplate", { key, options });
+
+  const template = TemplateManager.get(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> {
+  Naite.t(`resolveRenderedTemplate${key}`, { key, result });
+
+  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 = unique(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 {
+      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}`,
+    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 = unique(
+    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);
+      !isTest() &&
+        console.log(
+          chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, "")}`),
+        );
+      return dstFilePath;
+    }),
+  );
+}

package/src/syncer/entity-operations.ts

@@ -0,0 +1,65 @@
+import chalk from "chalk";
+import { rm } from "fs/promises";
+import { Sonamu } from "../api/sonamu";
+import { EntityManager } from "../entity/entity-manager";
+import { BadRequestException } from "../exceptions/so-exceptions";
+import type { TemplateOptions } from "../types/types";
+import { isTest } from "../utils/controller";
+import { exists } from "../utils/fs-utils";
+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.flatMap((target) => [
+          `${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`,
+        ]),
+      ];
+    }
+  })(); // iife
+
+  for await (const delPath of delPaths) {
+    if (await exists(delPath)) {
+      !isTest() && console.log(chalk.red(`DELETE ${delPath}`));
+      await rm(delPath, { recursive: true, force: true });
+    } else {
+      !isTest() && console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
+    }
+  }
+
+  // reload entities
+  await EntityManager.reload();
+
+  return { delPaths };
+}