sonamu 0.5.6 → 0.6.0

package/src/migration/migrator.ts

@@ -1,4 +1,4 @@
-import _ from "lodash";
+import * as _ from "lodash-es";
 import knex, { Knex } from "knex";
 import chalk from "chalk";
 import { DateTime } from "luxon";
@@ -73,63 +73,24 @@ export class Migrator {
     }
   }
 
-  private async getMigrationCodes(): Promise<{
-    normal: MigrationCode[];
-    onlyTs: MigrationCode[];
-    onlyJs: MigrationCode[];
-  }> {
-    const srcMigrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
-    const distMigrationsDir = `${Sonamu.apiRootPath}/dist/migrations`;
+  private async getMigrationCodes(): Promise<MigrationCode[]> {
+    const srcMigrationsDir = path.join(Sonamu.apiRootPath, "src", "migrations"); // 이건 환경에 관계없이 항상 src에서 찾아야 해요.
 
     if (!(await exists(srcMigrationsDir))) {
       await mkdir(srcMigrationsDir, {
         recursive: true,
       });
     }
-    if (!(await exists(distMigrationsDir))) {
-      await mkdir(distMigrationsDir, {
-        recursive: true,
-      });
-    }
-    const srcMigrations = (await readdir(srcMigrationsDir))
-      .filter((f) => f.endsWith(".ts"))
-      .map((f) => f.split(".")[0]);
-    const distMigrations = (await readdir(distMigrationsDir))
-      .filter((f) => f.endsWith(".js"))
-      .map((f) => f.split(".")[0]);
-
-    const normal = _.intersection(srcMigrations, distMigrations)
-      .map((filename) => {
-        return {
-          name: filename,
-          path: path.join(srcMigrationsDir, filename) + ".ts",
-        };
-      })
-      .sort((a, b) => (a > b ? 1 : -1));
 
-    const onlyTs = _.difference(srcMigrations, distMigrations).map(
-      (filename) => {
-        return {
-          name: filename,
-          path: path.join(srcMigrationsDir, filename) + ".ts",
-        };
-      }
-    );
-
-    const onlyJs = _.difference(distMigrations, srcMigrations).map(
-      (filename) => {
-        return {
-          name: filename,
-          path: path.join(distMigrationsDir, filename) + ".js",
-        };
-      }
-    );
+    const codes = (await readdir(srcMigrationsDir))
+      .filter((f) => f.endsWith(".ts"))
+      .map((f) => ({
+        name: f.replace(".ts", ""),
+        path: path.join(srcMigrationsDir, f),
+      }))
+      .sort((a, b) => (a.name < b.name ? 1 : -1)); // 이름 내림차순 정렬(최신순)
 
-    return {
-      normal,
-      onlyTs,
-      onlyJs,
-    };
+    return codes;
   }
 
   /**
@@ -142,25 +103,7 @@ export class Migrator {
    * @returns
    */
   async getStatus(): Promise<MigrationStatus> {
-    const { normal, onlyTs, onlyJs } = await this.getMigrationCodes();
-    if (onlyTs.length > 0) {
-      console.debug({ onlyTs });
-      throw new ServiceUnavailableException(
-        `There are un-compiled TS migration files.\nPlease compile them first. You might want to run a development server with HMR.\n\n${onlyTs
-          .map((f) => f.name)
-          .join("\n")}`
-      );
-    }
-    if (onlyJs.length > 0) {
-      console.debug({ onlyJs });
-      await Promise.all(
-        onlyJs.map(async (f) => {
-          execSync(
-            `rm -f ${f.path.replace("/src/", "/dist/").replace(".ts", ".js")}`
-          );
-        })
-      );
-    }
+    const codes = await this.getMigrationCodes();
 
     const connKeys = Object.keys(Sonamu.dbConfig).filter(
       (key) => key.endsWith("_slave") === false
@@ -187,7 +130,7 @@ export class Migrator {
           try {
             const [, fdList] = await tConn.migrate.list();
             return fdList.map((fd: { file: string }) =>
-              fd.file.replace(".js", "")
+              fd.file.replace(".ts", "")
             );
           } catch (err) {
             return [];
@@ -222,6 +165,11 @@ export class Migrator {
     const preparedCodes: GenMigrationCode[] = await (async () => {
       const status0conn = statuses.find((status) => status.status === 0);
       if (status0conn === undefined) {
+        console.warn(
+          chalk.yellow(
+            `While trying to prepare migration codes, we found that there is no database to compare migrations. We need at least one database where every migration is applied(status === 0). You might want to apply your existing migrations to one of the databases.`
+          )
+        );
         return [];
       }
 
@@ -235,14 +183,10 @@ export class Migrator {
 
     return {
       conns: statuses,
-      codes: normal,
+      codes,
       preparedCodes,
     };
     /*
-    TS/JS 코드 컴파일 상태 확인
-    1. 원본 파일 없는 JS파일이 존재하는 경우: 삭제
-    2. 컴파일 되지 않은 TS파일이 존재하는 경우: throw 쳐서 데브 서버 오픈 요청
-    
     DB 마이그레이션 상태 확인
     1. 전체 DB설정에 대해서 현재 마이그레이션 상태 확인
     - connKey: string
@@ -355,12 +299,9 @@ export class Migrator {
       );
     }
 
-    const delFiles = codeNames
-      .map((codeName) => [
-        `${Sonamu.apiRootPath}/src/migrations/${codeName}.ts`,
-        `${Sonamu.apiRootPath}/dist/migrations/${codeName}.js`,
-      ])
-      .flat();
+    const delFiles = codeNames.map(
+      (codeName) => `${Sonamu.apiRootPath}/src/migrations/${codeName}.ts`
+    );
 
     const res = await Promise.all(
       delFiles.map(async (delFile) => {
@@ -421,14 +362,13 @@ export class Migrator {
     ];
     const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     const delList = pendingList.map((df) => {
-      return path.join(migrationsDir, df.file).replace(".js", ".ts");
+      return path.join(migrationsDir, df.file);
     });
     for (let p of delList) {
       if (await exists(p)) {
         await unlink(p);
       }
     }
-    await this.cleanUpDist(true);
   }
 
   /**
@@ -553,75 +493,6 @@ export class Migrator {
     console.dir({ rollbackAllResult }, { depth: null });
     console.timeEnd(chalk.red("rollback:"));
   }
-
-  /**
-   * 빌드된 마이그레이션 파일을 삭제합니다.
-   *
-   * CLI에서 사용됩니다.
-   *
-   * @param force 강제 삭제 여부
-   * @returns
-   */
-  async cleanUpDist(force: boolean = false): Promise<void> {
-    async function getFilesUnder(dir: string): Promise<string[]> {
-      const migrationPath = path.join(Sonamu.apiRootPath, dir, "migrations");
-      if (!(await exists(migrationPath))) {
-        await mkdir(migrationPath, {
-          recursive: true,
-        });
-      }
-      return (await readdir(migrationPath)).filter(
-        (filename) => filename.startsWith(".") === false
-      );
-    }
-
-    const files = {
-      src: await getFilesUnder("src"),
-      dist: await getFilesUnder("dist"),
-    };
-
-    const diffOnSrc = _.differenceBy(
-      files.src,
-      files.dist,
-      (filename) => filename.split(".")[0]
-    );
-    if (diffOnSrc.length > 0) {
-      throw new Error(
-        "컴파일 되지 않은 파일이 있습니다.\n" + diffOnSrc.join("\n")
-      );
-    }
-
-    const diffOnDist = _.differenceBy(
-      files.dist,
-      files.src,
-      (filename) => filename.split(".")[0]
-    );
-    if (diffOnDist.length > 0) {
-      console.log(chalk.red("원본 ts파일을 찾을 수 없는 js파일이 있습니다."));
-      console.log(diffOnDist);
-
-      if (!force) {
-        const answer = await prompts({
-          type: "confirm",
-          name: "value",
-          message: "삭제를 진행하시겠습니까?",
-          initial: true,
-        });
-        if (answer.value === false) {
-          return;
-        }
-      }
-
-      const filesToRm = diffOnDist.map((filename) => {
-        return path.join(Sonamu.apiRootPath, "dist", "migrations", filename);
-      });
-      for (const filePath of filesToRm) {
-        await unlink(filePath);
-      }
-      console.log(chalk.green(`${filesToRm.length}건 삭제되었습니다!`));
-    }
-  }
-
   /**
    * Shadow DB 테스트를 진행합니다.
    *

package/src/naite/naite.ts

@@ -0,0 +1,70 @@
+import { Sonamu } from "../api/sonamu";
+
+export class Naite {
+  // 테스트 로그 기록
+  static t(name: string, value: any) {
+    const context = Sonamu.getContext();
+    const store = context?.naiteStore;
+
+    if (!store) {
+      return;
+    }
+    if (store.has(name)) {
+      // 이미 값이 있는 경우
+      if (Array.isArray(store.get(name))) {
+        // 배열에 추가
+        store.set(name, [...store.get(name), value]);
+      } else {
+        // 배열이 아닌 경우 배열로 변환
+        store.set(name, [store.get(name), value]);
+      }
+    } else {
+      // 값이 없는 경우 추가
+      store.set(name, value);
+    }
+  }
+
+  // 테스트에서 값 가져오기
+  static get(name: string): any {
+    const context = Sonamu.getContext();
+    if (!context?.naiteStore || !context.naiteStore.has(name)) {
+      throw new Error(`Naite.get: \`${name}\` not found`);
+    }
+    return context?.naiteStore?.get(name);
+  }
+
+  // 전체 리스트 가져오기
+  static getAll(): { [key: string]: any } {
+    const context = Sonamu.getContext();
+    if (!context?.naiteStore) {
+      return {};
+    }
+    return Object.fromEntries(context.naiteStore.entries());
+  }
+
+  // expect 래퍼 (CJS-ESM 이슈로 현재 사용불가)
+  // static expect(name: string) {
+  //   if (!this.vitestExpect) {
+  //     throw new Error("Vitest is not initialized");
+  //   }
+  //   return this.vitestExpect(this.get(name));
+  // }
+
+  // 일반 로그 레벨
+  static d(_message: string) {
+    // TODO: Logger 연결
+    console.log(`[DEBUG] ${_message}`);
+  }
+  static i(_message: string) {
+    // TODO: Logger 연결
+    console.log(`[INFO] ${_message}`);
+  }
+  static w(_message: string) {
+    // TODO: Logger 연결
+    console.log(`[WARN] ${_message}`);
+  }
+  static e(_message: string) {
+    // TODO: Logger 연결
+    console.log(`[ERROR] ${_message}`);
+  }
+}

package/src/syncer/api-parser.ts

@@ -0,0 +1,299 @@
+import { ApiParam, ApiParamType } from "../types/types";
+import { readFile } from "fs/promises";
+import * as _ from "lodash-es";
+import ts from "typescript";
+import { ExtendedApi, registeredApis } from "../api/decorators";
+import inflection from "inflection";
+import assert from "assert";
+import { AbsolutePath } from "../utils/path-utils";
+
+/**
+ * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
+ * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
+ * @param filePath - 파싱할 TypeScript 파일의 절대 경로
+ * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
+ */
+export async function readApisFromFile(filePath: AbsolutePath) {
+  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();
+      }
+
+      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
+    );
+    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);
+}