sonamu 0.6.0 → 0.7.0

package/dist/syncer/api-parser.js

@@ -1,8 +1,9 @@
+import assert from "assert";
 import { readFile } from "node:fs/promises";
+import inflection from "inflection";
 import ts from "typescript";
 import { registeredApis } from "../api/decorators.js";
-import inflection from "inflection";
-import assert from "assert";
+import { validateMethodName } from "../api/validator.js";
 /**
  * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
  * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
@@ -25,6 +26,7 @@ import assert from "assert";
         if (ts.isMethodDeclaration(node)) {
             if (ts.isIdentifier(node.name)) {
                 methodName = node.name.escapedText.toString();
+                validateMethodName(methodName);
             }
             const typeParameters = (node.typeParameters ?? []).map((typeParam)=>{
                 const tp = typeParam;
@@ -75,11 +77,14 @@ import assert from "assert";
     // 등록된 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
+            typeParameters: foundMethod?.typeParameters,
+            parameters: foundMethod?.parameters,
+            returnType: foundMethod?.returnType
         };
     });
     return extendedApis;
@@ -103,61 +108,67 @@ function resolveTypeNode(typeNode) {
         case ts.SyntaxKind.VoidKeyword:
             return "void";
         case ts.SyntaxKind.LiteralType:
-            const literal = typeNode.literal;
-            if (ts.isStringLiteral(literal)) {
+            {
+                const literal = typeNode.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;
                 return {
-                    t: "string-literal",
-                    value: literal.text
+                    t: "array",
+                    elementsType: resolveTypeNode(arrNode.elementType)
                 };
-            } else if (ts.isNumericLiteral(literal)) {
+            }
+        case ts.SyntaxKind.TypeLiteral:
+            {
+                const literalNode = typeNode;
                 return {
-                    t: "numeric-literal",
-                    value: Number(literal.text)
+                    t: "object",
+                    props: literalNode.members.map((member)=>{
+                        if (ts.isIndexSignatureDeclaration(member)) {
+                            assert(member.parameters[0]);
+                            const res = resolveParamDec({
+                                name: member.parameters[0].name,
+                                type: member.parameters[0].type
+                            });
+                            return resolveParamDec({
+                                name: {
+                                    escapedText: `[${res.name}${res.optional ? "?" : ""}: ${res.type}]`
+                                },
+                                type: member.type
+                            });
+                        } else {
+                            return resolveParamDec({
+                                name: member.name,
+                                type: member.type,
+                                optional: member.questionToken !== undefined
+                            });
+                        }
+                    })
                 };
-            } 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;
-            return {
-                t: "array",
-                elementsType: resolveTypeNode(arrNode.elementType)
-            };
-        case ts.SyntaxKind.TypeLiteral:
-            const literalNode = typeNode;
-            return {
-                t: "object",
-                props: literalNode.members.map((member)=>{
-                    if (ts.isIndexSignatureDeclaration(member)) {
-                        assert(member.parameters[0]);
-                        const res = resolveParamDec({
-                            name: member.parameters[0].name,
-                            type: member.parameters[0].type
-                        });
-                        return resolveParamDec({
-                            name: {
-                                escapedText: `[${res.name}${res.optional ? "?" : ""}: ${res.type}]`
-                            },
-                            type: member.type
-                        });
-                    } else {
-                        return resolveParamDec({
-                            name: member.name,
-                            type: member.type,
-                            optional: member.questionToken !== undefined
-                        });
-                    }
-                })
-            };
         case ts.SyntaxKind.TypeReference:
             return {
                 t: "ref",
@@ -226,4 +237,4 @@ function printNode(node, sourceFile) {
     return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/api-parser.ts"],"sourcesContent":["import { ApiParam, ApiParamType } from \"../types/types\";\nimport { readFile } from \"fs/promises\";\nimport * as _ from \"lodash-es\";\nimport ts from \"typescript\";\nimport { ExtendedApi, registeredApis } from \"../api/decorators\";\nimport inflection from \"inflection\";\nimport assert from \"assert\";\nimport { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.\n * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.\n * @param filePath - 파싱할 TypeScript 파일의 절대 경로\n * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)\n */\nexport async function readApisFromFile(filePath: AbsolutePath) {\n  if (!filePath.endsWith(\".ts\")) { \n    throw new Error(`${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`);\n  }\n  \n  const sourceFile = ts.createSourceFile(\n    filePath,\n    (await readFile(filePath)).toString(),\n    ts.ScriptTarget.Latest\n  );\n\n  const methods: Omit<ExtendedApi, \"path\" | \"options\">[] = [];\n  let modelName: string = \"UnknownModel\";\n  let methodName: string = \"unknownMethod\";\n  const visitor = (node: ts.Node) => {\n    if (ts.isClassDeclaration(node)) {\n      if (node.name && ts.isIdentifier(node.name)) {\n        modelName = node.name.escapedText.toString().replace(/Class$/, \"\");\n      }\n    }\n    if (ts.isMethodDeclaration(node)) {\n      if (ts.isIdentifier(node.name)) {\n        methodName = node.name.escapedText.toString();\n      }\n\n      const typeParameters: ApiParamType.TypeParam[] = (\n        node.typeParameters ?? []\n      ).map((typeParam) => {\n        const tp = typeParam as ts.TypeParameterDeclaration;\n\n        return {\n          t: \"type-param\",\n          id: tp.name.escapedText.toString(),\n          constraint: tp.constraint\n            ? resolveTypeNode(tp.constraint)\n            : undefined,\n        };\n      });\n      const parameters: ApiParam[] = node.parameters.map((paramDec, index) => {\n        const defaultDef = printNode(paramDec.initializer, sourceFile);\n\n        // 기본값이 있는 경우 paramDec.type가 undefined로 나옴\n\n        return resolveParamDec(\n          {\n            name: paramDec.name,\n            type: paramDec.type as ts.TypeNode,\n            optional:\n              paramDec.questionToken !== undefined ||\n              paramDec.initializer !== undefined,\n            defaultDef,\n          },\n          index\n        );\n      });\n      if (node.type === undefined) {\n        throw new Error(\n          `리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`\n        );\n      }\n      const returnType = resolveTypeNode(node.type!);\n\n      methods.push({\n        modelName,\n        methodName,\n        typeParameters,\n        parameters,\n        returnType,\n      });\n    }\n    ts.forEachChild(node, visitor);\n  };\n  visitor(sourceFile);\n\n  if (methods.length === 0) {\n    return [];\n  }\n\n  // 현재 파일의 등록된 API 필터\n  const currentModelApis = registeredApis.filter((api) => {\n    return methods.find(\n      (method) =>\n        method.modelName === api.modelName &&\n        method.methodName === api.methodName\n    );\n  });\n  if (currentModelApis.length === 0) {\n    // const p = path.join(tmpdir(), \"sonamu-syncer-error.json\");\n    // writeFileSync(p, JSON.stringify(registeredApis, null, 2));\n    // execSync(`open ${p}`);\n    throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);\n  }\n\n  // 등록된 API에 현재 메소드 타입 정보 확장\n  const extendedApis = currentModelApis.map((api) => {\n    const foundMethod = methods.find(\n      (method) =>\n        method.modelName === api.modelName &&\n        method.methodName === api.methodName\n    );\n    return {\n      ...api,\n      typeParameters: foundMethod!.typeParameters,\n      parameters: foundMethod!.parameters,\n      returnType: foundMethod!.returnType,\n    };\n  });\n  return extendedApis;\n}\n\nfunction resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {\n  switch (typeNode?.kind) {\n    case ts.SyntaxKind.AnyKeyword:\n      return \"any\";\n    case ts.SyntaxKind.UnknownKeyword:\n      return \"unknown\";\n    case ts.SyntaxKind.StringKeyword:\n      return \"string\";\n    case ts.SyntaxKind.NumberKeyword:\n      return \"number\";\n    case ts.SyntaxKind.BooleanKeyword:\n      return \"boolean\";\n    case ts.SyntaxKind.UndefinedKeyword:\n      return \"undefined\";\n    case ts.SyntaxKind.NullKeyword:\n      return \"null\";\n    case ts.SyntaxKind.VoidKeyword:\n      return \"void\";\n    case ts.SyntaxKind.LiteralType:\n      const literal = (typeNode as ts.LiteralTypeNode).literal;\n      if (ts.isStringLiteral(literal)) {\n        return {\n          t: \"string-literal\",\n          value: literal.text,\n        };\n      } else if (ts.isNumericLiteral(literal)) {\n        return {\n          t: \"numeric-literal\",\n          value: Number(literal.text),\n        };\n      } else {\n        if (literal.kind === ts.SyntaxKind.NullKeyword) {\n          return \"null\";\n        } else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {\n          return \"undefined\";\n        } else if (literal.kind === ts.SyntaxKind.TrueKeyword) {\n          return \"true\";\n        } else if (literal.kind === ts.SyntaxKind.FalseKeyword) {\n          return \"false\";\n        }\n        throw new Error(\"알 수 없는 리터럴\");\n      }\n    case ts.SyntaxKind.ArrayType:\n      const arrNode = typeNode as ts.ArrayTypeNode;\n      return {\n        t: \"array\",\n        elementsType: resolveTypeNode(arrNode.elementType),\n      };\n    case ts.SyntaxKind.TypeLiteral:\n      const literalNode = typeNode as ts.TypeLiteralNode;\n      return {\n        t: \"object\",\n        props: literalNode.members.map((member) => {\n          if (ts.isIndexSignatureDeclaration(member)) {\n            assert(member.parameters[0]);\n            const res = resolveParamDec({\n              name: member.parameters[0].name as ts.Identifier,\n              type: member.parameters[0].type as ts.TypeNode,\n            });\n\n            return resolveParamDec({\n              name: {\n                escapedText: `[${res.name}${res.optional ? \"?\" : \"\"}: ${\n                  res.type\n                }]`,\n              } as ts.Identifier,\n              type: member.type as ts.TypeNode,\n            });\n          } else {\n            return resolveParamDec({\n              name: (member as ts.PropertySignature).name as ts.Identifier,\n              type: (member as ts.PropertySignature).type as ts.TypeNode,\n              optional:\n                (member as ts.PropertySignature).questionToken !== undefined,\n            });\n          }\n        }),\n      };\n    case ts.SyntaxKind.TypeReference:\n      return {\n        t: \"ref\",\n        id: (\n          (typeNode as ts.TypeReferenceNode).typeName as ts.Identifier\n        ).escapedText.toString(),\n        args: (typeNode as ts.TypeReferenceNode).typeArguments?.map((typeArg) =>\n          resolveTypeNode(typeArg)\n        ),\n      };\n    case ts.SyntaxKind.UnionType:\n      return {\n        t: \"union\",\n        types: (typeNode as ts.UnionTypeNode).types.map((type) =>\n          resolveTypeNode(type)\n        ),\n      };\n    case ts.SyntaxKind.IntersectionType:\n      return {\n        t: \"intersection\",\n        types: (typeNode as ts.IntersectionTypeNode).types.map((type) =>\n          resolveTypeNode(type)\n        ),\n      };\n    case ts.SyntaxKind.IndexedAccessType:\n      return {\n        t: \"indexed-access\",\n        object: resolveTypeNode(\n          (typeNode as ts.IndexedAccessTypeNode).objectType\n        ),\n        index: resolveTypeNode(\n          (typeNode as ts.IndexedAccessTypeNode).indexType\n        ),\n      };\n    case ts.SyntaxKind.TupleType:\n      if (ts.isTupleTypeNode(typeNode)) {\n        return {\n          t: \"tuple-type\",\n          elements: typeNode.elements.map((elem) => resolveTypeNode(elem)),\n        };\n      }\n      break;\n    case undefined:\n      throw new Error(`typeNode undefined`);\n  }\n\n  console.debug(typeNode);\n  throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);\n}\n\nfunction resolveParamDec(\n  paramDec: {\n    name: ts.BindingName;\n    type: ts.TypeNode;\n    optional?: boolean;\n    defaultDef?: string;\n  },\n  index: number = 0\n): ApiParam {\n  const name = paramDec.name as ts.Identifier;\n  const type = resolveTypeNode(paramDec.type);\n\n  if (name === undefined) {\n    console.debug({ name, type, paramDec });\n  }\n\n  const result: ApiParam = {\n    name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,\n    type,\n    optional: paramDec.optional === true,\n    defaultDef: paramDec?.defaultDef,\n  };\n\n  // 구조분해할당의 경우 타입이름 사용\n  if (\n    ts.isObjectBindingPattern(name) &&\n    ts.isTypeReferenceNode(paramDec.type) &&\n    ts.isIdentifier(paramDec.type.typeName)\n  ) {\n    result.name = inflection.camelize(paramDec.type.typeName.text, true);\n  }\n\n  return result;\n}\n\nfunction printNode(\n  node: ts.Node | undefined,\n  sourceFile: ts.SourceFile\n): string | undefined {\n  if (node === undefined) {\n    return undefined;\n  }\n\n  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);\n}\n"],"names":["readFile","ts","registeredApis","inflection","assert","readApisFromFile","filePath","endsWith","Error","sourceFile","createSourceFile","toString","ScriptTarget","Latest","methods","modelName","methodName","visitor","node","isClassDeclaration","name","isIdentifier","escapedText","replace","isMethodDeclaration","typeParameters","map","typeParam","tp","t","id","constraint","resolveTypeNode","undefined","parameters","paramDec","index","defaultDef","printNode","initializer","resolveParamDec","type","optional","questionToken","returnType","push","forEachChild","length","currentModelApis","filter","api","find","method","extendedApis","foundMethod","typeNode","kind","SyntaxKind","AnyKeyword","UnknownKeyword","StringKeyword","NumberKeyword","BooleanKeyword","UndefinedKeyword","NullKeyword","VoidKeyword","LiteralType","literal","isStringLiteral","value","text","isNumericLiteral","Number","TrueKeyword","FalseKeyword","ArrayType","arrNode","elementsType","elementType","TypeLiteral","literalNode","props","members","member","isIndexSignatureDeclaration","res","TypeReference","typeName","args","typeArguments","typeArg","UnionType","types","IntersectionType","IndexedAccessType","object","objectType","indexType","TupleType","isTupleTypeNode","elements","elem","console","debug","result","isObjectBindingPattern","isTypeReferenceNode","camelize","printer","createPrinter","newLine","NewLineKind","LineFeed","EmitHint","Unspecified"],"mappings":"AACA,SAASA,QAAQ,QAAQ,mBAAc;AAEvC,OAAOC,QAAQ,aAAa;AAC5B,SAAsBC,cAAc,QAAQ,uBAAoB;AAChE,OAAOC,gBAAgB,aAAa;AACpC,OAAOC,YAAY,SAAS;AAG5B;;;;;CAKC,GACD,OAAO,eAAeC,iBAAiBC,QAAsB;IAC3D,IAAI,CAACA,SAASC,QAAQ,CAAC,QAAQ;QAC7B,MAAM,IAAIC,MAAM,GAAGF,SAAS,6GAA6G,CAAC;IAC5I;IAEA,MAAMG,aAAaR,GAAGS,gBAAgB,CACpCJ,UACA,AAAC,CAAA,MAAMN,SAASM,SAAQ,EAAGK,QAAQ,IACnCV,GAAGW,YAAY,CAACC,MAAM;IAGxB,MAAMC,UAAmD,EAAE;IAC3D,IAAIC,YAAoB;IACxB,IAAIC,aAAqB;IACzB,MAAMC,UAAU,CAACC;QACf,IAAIjB,GAAGkB,kBAAkB,CAACD,OAAO;YAC/B,IAAIA,KAAKE,IAAI,IAAInB,GAAGoB,YAAY,CAACH,KAAKE,IAAI,GAAG;gBAC3CL,YAAYG,KAAKE,IAAI,CAACE,WAAW,CAACX,QAAQ,GAAGY,OAAO,CAAC,UAAU;YACjE;QACF;QACA,IAAItB,GAAGuB,mBAAmB,CAACN,OAAO;YAChC,IAAIjB,GAAGoB,YAAY,CAACH,KAAKE,IAAI,GAAG;gBAC9BJ,aAAaE,KAAKE,IAAI,CAACE,WAAW,CAACX,QAAQ;YAC7C;YAEA,MAAMc,iBAA2C,AAC/CP,CAAAA,KAAKO,cAAc,IAAI,EAAE,AAAD,EACxBC,GAAG,CAAC,CAACC;gBACL,MAAMC,KAAKD;gBAEX,OAAO;oBACLE,GAAG;oBACHC,IAAIF,GAAGR,IAAI,CAACE,WAAW,CAACX,QAAQ;oBAChCoB,YAAYH,GAAGG,UAAU,GACrBC,gBAAgBJ,GAAGG,UAAU,IAC7BE;gBACN;YACF;YACA,MAAMC,aAAyBhB,KAAKgB,UAAU,CAACR,GAAG,CAAC,CAACS,UAAUC;gBAC5D,MAAMC,aAAaC,UAAUH,SAASI,WAAW,EAAE9B;gBAEnD,0CAA0C;gBAE1C,OAAO+B,gBACL;oBACEpB,MAAMe,SAASf,IAAI;oBACnBqB,MAAMN,SAASM,IAAI;oBACnBC,UACEP,SAASQ,aAAa,KAAKV,aAC3BE,SAASI,WAAW,KAAKN;oBAC3BI;gBACF,GACAD;YAEJ;YACA,IAAIlB,KAAKuB,IAAI,KAAKR,WAAW;gBAC3B,MAAM,IAAIzB,MACR,CAAC,mBAAmB,EAAEO,UAAU,CAAC,EAAEC,YAAY;YAEnD;YACA,MAAM4B,aAAaZ,gBAAgBd,KAAKuB,IAAI;YAE5C3B,QAAQ+B,IAAI,CAAC;gBACX9B;gBACAC;gBACAS;gBACAS;gBACAU;YACF;QACF;QACA3C,GAAG6C,YAAY,CAAC5B,MAAMD;IACxB;IACAA,QAAQR;IAER,IAAIK,QAAQiC,MAAM,KAAK,GAAG;QACxB,OAAO,EAAE;IACX;IAEA,oBAAoB;IACpB,MAAMC,mBAAmB9C,eAAe+C,MAAM,CAAC,CAACC;QAC9C,OAAOpC,QAAQqC,IAAI,CACjB,CAACC,SACCA,OAAOrC,SAAS,KAAKmC,IAAInC,SAAS,IAClCqC,OAAOpC,UAAU,KAAKkC,IAAIlC,UAAU;IAE1C;IACA,IAAIgC,iBAAiBD,MAAM,KAAK,GAAG;QACjC,6DAA6D;QAC7D,6DAA6D;QAC7D,yBAAyB;QACzB,MAAM,IAAIvC,MAAM,CAAC,yBAAyB,EAAEF,UAAU;IACxD;IAEA,2BAA2B;IAC3B,MAAM+C,eAAeL,iBAAiBtB,GAAG,CAAC,CAACwB;QACzC,MAAMI,cAAcxC,QAAQqC,IAAI,CAC9B,CAACC,SACCA,OAAOrC,SAAS,KAAKmC,IAAInC,SAAS,IAClCqC,OAAOpC,UAAU,KAAKkC,IAAIlC,UAAU;QAExC,OAAO;YACL,GAAGkC,GAAG;YACNzB,gBAAgB6B,YAAa7B,cAAc;YAC3CS,YAAYoB,YAAapB,UAAU;YACnCU,YAAYU,YAAaV,UAAU;QACrC;IACF;IACA,OAAOS;AACT;AAEA,SAASrB,gBAAgBuB,QAAqB;IAC5C,OAAQA,UAAUC;QAChB,KAAKvD,GAAGwD,UAAU,CAACC,UAAU;YAC3B,OAAO;QACT,KAAKzD,GAAGwD,UAAU,CAACE,cAAc;YAC/B,OAAO;QACT,KAAK1D,GAAGwD,UAAU,CAACG,aAAa;YAC9B,OAAO;QACT,KAAK3D,GAAGwD,UAAU,CAACI,aAAa;YAC9B,OAAO;QACT,KAAK5D,GAAGwD,UAAU,CAACK,cAAc;YAC/B,OAAO;QACT,KAAK7D,GAAGwD,UAAU,CAACM,gBAAgB;YACjC,OAAO;QACT,KAAK9D,GAAGwD,UAAU,CAACO,WAAW;YAC5B,OAAO;QACT,KAAK/D,GAAGwD,UAAU,CAACQ,WAAW;YAC5B,OAAO;QACT,KAAKhE,GAAGwD,UAAU,CAACS,WAAW;YAC5B,MAAMC,UAAU,AAACZ,SAAgCY,OAAO;YACxD,IAAIlE,GAAGmE,eAAe,CAACD,UAAU;gBAC/B,OAAO;oBACLtC,GAAG;oBACHwC,OAAOF,QAAQG,IAAI;gBACrB;YACF,OAAO,IAAIrE,GAAGsE,gBAAgB,CAACJ,UAAU;gBACvC,OAAO;oBACLtC,GAAG;oBACHwC,OAAOG,OAAOL,QAAQG,IAAI;gBAC5B;YACF,OAAO;gBACL,IAAIH,QAAQX,IAAI,KAAKvD,GAAGwD,UAAU,CAACO,WAAW,EAAE;oBAC9C,OAAO;gBACT,OAAO,IAAIG,QAAQX,IAAI,KAAKvD,GAAGwD,UAAU,CAACM,gBAAgB,EAAE;oBAC1D,OAAO;gBACT,OAAO,IAAII,QAAQX,IAAI,KAAKvD,GAAGwD,UAAU,CAACgB,WAAW,EAAE;oBACrD,OAAO;gBACT,OAAO,IAAIN,QAAQX,IAAI,KAAKvD,GAAGwD,UAAU,CAACiB,YAAY,EAAE;oBACtD,OAAO;gBACT;gBACA,MAAM,IAAIlE,MAAM;YAClB;QACF,KAAKP,GAAGwD,UAAU,CAACkB,SAAS;YAC1B,MAAMC,UAAUrB;YAChB,OAAO;gBACL1B,GAAG;gBACHgD,cAAc7C,gBAAgB4C,QAAQE,WAAW;YACnD;QACF,KAAK7E,GAAGwD,UAAU,CAACsB,WAAW;YAC5B,MAAMC,cAAczB;YACpB,OAAO;gBACL1B,GAAG;gBACHoD,OAAOD,YAAYE,OAAO,CAACxD,GAAG,CAAC,CAACyD;oBAC9B,IAAIlF,GAAGmF,2BAA2B,CAACD,SAAS;wBAC1C/E,OAAO+E,OAAOjD,UAAU,CAAC,EAAE;wBAC3B,MAAMmD,MAAM7C,gBAAgB;4BAC1BpB,MAAM+D,OAAOjD,UAAU,CAAC,EAAE,CAACd,IAAI;4BAC/BqB,MAAM0C,OAAOjD,UAAU,CAAC,EAAE,CAACO,IAAI;wBACjC;wBAEA,OAAOD,gBAAgB;4BACrBpB,MAAM;gCACJE,aAAa,CAAC,CAAC,EAAE+D,IAAIjE,IAAI,GAAGiE,IAAI3C,QAAQ,GAAG,MAAM,GAAG,EAAE,EACpD2C,IAAI5C,IAAI,CACT,CAAC,CAAC;4BACL;4BACAA,MAAM0C,OAAO1C,IAAI;wBACnB;oBACF,OAAO;wBACL,OAAOD,gBAAgB;4BACrBpB,MAAM,AAAC+D,OAAgC/D,IAAI;4BAC3CqB,MAAM,AAAC0C,OAAgC1C,IAAI;4BAC3CC,UACE,AAACyC,OAAgCxC,aAAa,KAAKV;wBACvD;oBACF;gBACF;YACF;QACF,KAAKhC,GAAGwD,UAAU,CAAC6B,aAAa;YAC9B,OAAO;gBACLzD,GAAG;gBACHC,IAAI,AACF,AAACyB,SAAkCgC,QAAQ,CAC3CjE,WAAW,CAACX,QAAQ;gBACtB6E,MAAM,AAACjC,SAAkCkC,aAAa,EAAE/D,IAAI,CAACgE,UAC3D1D,gBAAgB0D;YAEpB;QACF,KAAKzF,GAAGwD,UAAU,CAACkC,SAAS;YAC1B,OAAO;gBACL9D,GAAG;gBACH+D,OAAO,AAACrC,SAA8BqC,KAAK,CAAClE,GAAG,CAAC,CAACe,OAC/CT,gBAAgBS;YAEpB;QACF,KAAKxC,GAAGwD,UAAU,CAACoC,gBAAgB;YACjC,OAAO;gBACLhE,GAAG;gBACH+D,OAAO,AAACrC,SAAqCqC,KAAK,CAAClE,GAAG,CAAC,CAACe,OACtDT,gBAAgBS;YAEpB;QACF,KAAKxC,GAAGwD,UAAU,CAACqC,iBAAiB;YAClC,OAAO;gBACLjE,GAAG;gBACHkE,QAAQ/D,gBACN,AAACuB,SAAsCyC,UAAU;gBAEnD5D,OAAOJ,gBACL,AAACuB,SAAsC0C,SAAS;YAEpD;QACF,KAAKhG,GAAGwD,UAAU,CAACyC,SAAS;YAC1B,IAAIjG,GAAGkG,eAAe,CAAC5C,WAAW;gBAChC,OAAO;oBACL1B,GAAG;oBACHuE,UAAU7C,SAAS6C,QAAQ,CAAC1E,GAAG,CAAC,CAAC2E,OAASrE,gBAAgBqE;gBAC5D;YACF;YACA;QACF,KAAKpE;YACH,MAAM,IAAIzB,MAAM,CAAC,kBAAkB,CAAC;IACxC;IAEA8F,QAAQC,KAAK,CAAChD;IACd,MAAM,IAAI/C,MAAM,CAAC,kBAAkB,EAAE+C,SAASC,IAAI,EAAE;AACtD;AAEA,SAAShB,gBACPL,QAKC,EACDC,QAAgB,CAAC;IAEjB,MAAMhB,OAAOe,SAASf,IAAI;IAC1B,MAAMqB,OAAOT,gBAAgBG,SAASM,IAAI;IAE1C,IAAIrB,SAASa,WAAW;QACtBqE,QAAQC,KAAK,CAAC;YAAEnF;YAAMqB;YAAMN;QAAS;IACvC;IAEA,MAAMqE,SAAmB;QACvBpF,MAAMA,KAAKE,WAAW,GAAGF,KAAKE,WAAW,CAACX,QAAQ,KAAK,CAAC,QAAQ,EAAEyB,OAAO;QACzEK;QACAC,UAAUP,SAASO,QAAQ,KAAK;QAChCL,YAAYF,UAAUE;IACxB;IAEA,qBAAqB;IACrB,IACEpC,GAAGwG,sBAAsB,CAACrF,SAC1BnB,GAAGyG,mBAAmB,CAACvE,SAASM,IAAI,KACpCxC,GAAGoB,YAAY,CAACc,SAASM,IAAI,CAAC8C,QAAQ,GACtC;QACAiB,OAAOpF,IAAI,GAAGjB,WAAWwG,QAAQ,CAACxE,SAASM,IAAI,CAAC8C,QAAQ,CAACjB,IAAI,EAAE;IACjE;IAEA,OAAOkC;AACT;AAEA,SAASlE,UACPpB,IAAyB,EACzBT,UAAyB;IAEzB,IAAIS,SAASe,WAAW;QACtB,OAAOA;IACT;IAEA,MAAM2E,UAAU3G,GAAG4G,aAAa,CAAC;QAAEC,SAAS7G,GAAG8G,WAAW,CAACC,QAAQ;IAAC;IACpE,OAAOJ,QAAQtE,SAAS,CAACrC,GAAGgH,QAAQ,CAACC,WAAW,EAAEhG,MAAMT;AAC1D"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/api-parser.ts"],"sourcesContent":["import assert from \"assert\";\nimport { readFile } from \"fs/promises\";\nimport inflection from \"inflection\";\nimport ts from \"typescript\";\nimport { type ExtendedApi, registeredApis } from \"../api/decorators\";\nimport { validateMethodName } from \"../api/validator\";\nimport type { ApiParam, ApiParamType } from \"../types/types\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.\n * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.\n * @param filePath - 파싱할 TypeScript 파일의 절대 경로\n * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)\n */\nexport async function readApisFromFile(filePath: AbsolutePath): Promise<ExtendedApi[]> {\n  if (!filePath.endsWith(\".ts\")) {\n    throw new Error(\n      `${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`,\n    );\n  }\n\n  const sourceFile = ts.createSourceFile(\n    filePath,\n    (await readFile(filePath)).toString(),\n    ts.ScriptTarget.Latest,\n  );\n\n  const methods: Omit<ExtendedApi, \"path\" | \"options\">[] = [];\n  let modelName: string = \"UnknownModel\";\n  let methodName: string = \"unknownMethod\";\n  const visitor = (node: ts.Node) => {\n    if (ts.isClassDeclaration(node)) {\n      if (node.name && ts.isIdentifier(node.name)) {\n        modelName = node.name.escapedText.toString().replace(/Class$/, \"\");\n      }\n    }\n    if (ts.isMethodDeclaration(node)) {\n      if (ts.isIdentifier(node.name)) {\n        methodName = node.name.escapedText.toString();\n        validateMethodName(methodName);\n      }\n\n      const typeParameters: ApiParamType.TypeParam[] = (node.typeParameters ?? []).map(\n        (typeParam) => {\n          const tp = typeParam as ts.TypeParameterDeclaration;\n\n          return {\n            t: \"type-param\",\n            id: tp.name.escapedText.toString(),\n            constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined,\n          };\n        },\n      );\n      const parameters: ApiParam[] = node.parameters.map((paramDec, index) => {\n        const defaultDef = printNode(paramDec.initializer, sourceFile);\n\n        // 기본값이 있는 경우 paramDec.type가 undefined로 나옴\n\n        return resolveParamDec(\n          {\n            name: paramDec.name,\n            type: paramDec.type as ts.TypeNode,\n            optional: paramDec.questionToken !== undefined || paramDec.initializer !== undefined,\n            defaultDef,\n          },\n          index,\n        );\n      });\n      if (node.type === undefined) {\n        throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);\n      }\n      const returnType = resolveTypeNode(node.type);\n\n      methods.push({\n        modelName,\n        methodName,\n        typeParameters,\n        parameters,\n        returnType,\n      });\n    }\n    ts.forEachChild(node, visitor);\n  };\n  visitor(sourceFile);\n\n  if (methods.length === 0) {\n    return [];\n  }\n\n  // 현재 파일의 등록된 API 필터\n  const currentModelApis = registeredApis.filter((api) => {\n    return methods.find(\n      (method) => method.modelName === api.modelName && method.methodName === api.methodName,\n    );\n  });\n  if (currentModelApis.length === 0) {\n    // const p = path.join(tmpdir(), \"sonamu-syncer-error.json\");\n    // writeFileSync(p, JSON.stringify(registeredApis, null, 2));\n    // execSync(`open ${p}`);\n    throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);\n  }\n\n  // 등록된 API에 현재 메소드 타입 정보 확장\n  const extendedApis = currentModelApis.map((api) => {\n    const foundMethod = methods.find(\n      (method) => method.modelName === api.modelName && method.methodName === api.methodName,\n    );\n    if (!foundMethod) {\n      throw new Error(`API ${api.modelName}.${api.methodName} not found in ${filePath}`);\n    }\n    return {\n      ...api,\n      typeParameters: foundMethod?.typeParameters,\n      parameters: foundMethod?.parameters,\n      returnType: foundMethod?.returnType,\n    };\n  });\n  return extendedApis;\n}\n\nfunction resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {\n  switch (typeNode?.kind) {\n    case ts.SyntaxKind.AnyKeyword:\n      return \"any\";\n    case ts.SyntaxKind.UnknownKeyword:\n      return \"unknown\";\n    case ts.SyntaxKind.StringKeyword:\n      return \"string\";\n    case ts.SyntaxKind.NumberKeyword:\n      return \"number\";\n    case ts.SyntaxKind.BooleanKeyword:\n      return \"boolean\";\n    case ts.SyntaxKind.UndefinedKeyword:\n      return \"undefined\";\n    case ts.SyntaxKind.NullKeyword:\n      return \"null\";\n    case ts.SyntaxKind.VoidKeyword:\n      return \"void\";\n    case ts.SyntaxKind.LiteralType: {\n      const literal = (typeNode as ts.LiteralTypeNode).literal;\n      if (ts.isStringLiteral(literal)) {\n        return {\n          t: \"string-literal\",\n          value: literal.text,\n        };\n      } else if (ts.isNumericLiteral(literal)) {\n        return {\n          t: \"numeric-literal\",\n          value: Number(literal.text),\n        };\n      } else {\n        if (literal.kind === ts.SyntaxKind.NullKeyword) {\n          return \"null\";\n        } else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {\n          return \"undefined\";\n        } else if (literal.kind === ts.SyntaxKind.TrueKeyword) {\n          return \"true\";\n        } else if (literal.kind === ts.SyntaxKind.FalseKeyword) {\n          return \"false\";\n        }\n        throw new Error(\"알 수 없는 리터럴\");\n      }\n    }\n    case ts.SyntaxKind.ArrayType: {\n      const arrNode = typeNode as ts.ArrayTypeNode;\n      return {\n        t: \"array\",\n        elementsType: resolveTypeNode(arrNode.elementType),\n      };\n    }\n    case ts.SyntaxKind.TypeLiteral: {\n      const literalNode = typeNode as ts.TypeLiteralNode;\n      return {\n        t: \"object\",\n        props: literalNode.members.map((member) => {\n          if (ts.isIndexSignatureDeclaration(member)) {\n            assert(member.parameters[0]);\n            const res = resolveParamDec({\n              name: member.parameters[0].name as ts.Identifier,\n              type: member.parameters[0].type as ts.TypeNode,\n            });\n\n            return resolveParamDec({\n              name: {\n                escapedText: `[${res.name}${res.optional ? \"?\" : \"\"}: ${res.type}]`,\n              } as ts.Identifier,\n              type: member.type as ts.TypeNode,\n            });\n          } else {\n            return resolveParamDec({\n              name: (member as ts.PropertySignature).name as ts.Identifier,\n              type: (member as ts.PropertySignature).type as ts.TypeNode,\n              optional: (member as ts.PropertySignature).questionToken !== undefined,\n            });\n          }\n        }),\n      };\n    }\n    case ts.SyntaxKind.TypeReference:\n      return {\n        t: \"ref\",\n        id: ((typeNode as ts.TypeReferenceNode).typeName as ts.Identifier).escapedText.toString(),\n        args: (typeNode as ts.TypeReferenceNode).typeArguments?.map((typeArg) =>\n          resolveTypeNode(typeArg),\n        ),\n      };\n    case ts.SyntaxKind.UnionType:\n      return {\n        t: \"union\",\n        types: (typeNode as ts.UnionTypeNode).types.map((type) => resolveTypeNode(type)),\n      };\n    case ts.SyntaxKind.IntersectionType:\n      return {\n        t: \"intersection\",\n        types: (typeNode as ts.IntersectionTypeNode).types.map((type) => resolveTypeNode(type)),\n      };\n    case ts.SyntaxKind.IndexedAccessType:\n      return {\n        t: \"indexed-access\",\n        object: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).objectType),\n        index: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).indexType),\n      };\n    case ts.SyntaxKind.TupleType:\n      if (ts.isTupleTypeNode(typeNode)) {\n        return {\n          t: \"tuple-type\",\n          elements: typeNode.elements.map((elem) => resolveTypeNode(elem)),\n        };\n      }\n      break;\n    case undefined:\n      throw new Error(`typeNode undefined`);\n  }\n\n  console.debug(typeNode);\n  throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);\n}\n\nfunction resolveParamDec(\n  paramDec: {\n    name: ts.BindingName;\n    type: ts.TypeNode;\n    optional?: boolean;\n    defaultDef?: string;\n  },\n  index: number = 0,\n): ApiParam {\n  const name = paramDec.name as ts.Identifier;\n  const type = resolveTypeNode(paramDec.type);\n\n  if (name === undefined) {\n    console.debug({ name, type, paramDec });\n  }\n\n  const result: ApiParam = {\n    name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,\n    type,\n    optional: paramDec.optional === true,\n    defaultDef: paramDec?.defaultDef,\n  };\n\n  // 구조분해할당의 경우 타입이름 사용\n  if (\n    ts.isObjectBindingPattern(name) &&\n    ts.isTypeReferenceNode(paramDec.type) &&\n    ts.isIdentifier(paramDec.type.typeName)\n  ) {\n    result.name = inflection.camelize(paramDec.type.typeName.text, true);\n  }\n\n  return result;\n}\n\nfunction printNode(node: ts.Node | undefined, sourceFile: ts.SourceFile): string | undefined {\n  if (node === undefined) {\n    return undefined;\n  }\n\n  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);\n}\n"],"names":["assert","readFile","inflection","ts","registeredApis","validateMethodName","readApisFromFile","filePath","endsWith","Error","sourceFile","createSourceFile","toString","ScriptTarget","Latest","methods","modelName","methodName","visitor","node","isClassDeclaration","name","isIdentifier","escapedText","replace","isMethodDeclaration","typeParameters","map","typeParam","tp","t","id","constraint","resolveTypeNode","undefined","parameters","paramDec","index","defaultDef","printNode","initializer","resolveParamDec","type","optional","questionToken","returnType","push","forEachChild","length","currentModelApis","filter","api","find","method","extendedApis","foundMethod","typeNode","kind","SyntaxKind","AnyKeyword","UnknownKeyword","StringKeyword","NumberKeyword","BooleanKeyword","UndefinedKeyword","NullKeyword","VoidKeyword","LiteralType","literal","isStringLiteral","value","text","isNumericLiteral","Number","TrueKeyword","FalseKeyword","ArrayType","arrNode","elementsType","elementType","TypeLiteral","literalNode","props","members","member","isIndexSignatureDeclaration","res","TypeReference","typeName","args","typeArguments","typeArg","UnionType","types","IntersectionType","IndexedAccessType","object","objectType","indexType","TupleType","isTupleTypeNode","elements","elem","console","debug","result","isObjectBindingPattern","isTypeReferenceNode","camelize","printer","createPrinter","newLine","NewLineKind","LineFeed","EmitHint","Unspecified"],"mappings":"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"}

package/dist/syncer/checksum.d.ts

@@ -1,5 +1,5 @@
-import { PathLike } from "fs";
-import { AbsolutePath } from "../utils/path-utils";
+import { type PathLike } from "fs";
+import type { AbsolutePath } from "../utils/path-utils";
 /**
  * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.
  * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: "/src/application/user/user.model.ts"

package/dist/syncer/checksum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,QAAQ,EAAE,MAAM,IAAI,CAAC;AAQhD,OAAO,EACL,YAAY,EAEb,MAAM,qBAAqB,CAAC;AAQ7B;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAC7D,YAAY,EAAE,CACf,CAYA;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,QAAQ,GACZ,OAAO,CAAC,OAAO,CAAC,CASlB"}
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,IAAI,CAAC;AAOrD,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,qBAAqB,CAAC;AASzE;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAU9E;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CASjF"}

package/dist/syncer/checksum.js

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

package/dist/syncer/code-generator.d.ts

@@ -1,5 +1,5 @@
-import { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from "../types/types";
-import { AbsolutePath } from "../utils/path-utils";
+import type { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from "../types/types";
+import type { AbsolutePath } from "../utils/path-utils";
 /**
  * 템플릿을 렌더링하고 파일로 생성합니다.
  * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
@@ -8,7 +8,7 @@ import { AbsolutePath } from "../utils/path-utils";
  * @param _generateOptions - 생성 옵션 (overwrite 여부)
  * @returns 생성된 파일 경로 배열
  */
-export declare function generateTemplate(key: TemplateKey, templateOptions: any, _generateOptions?: GenerateOptions): Promise<AbsolutePath[]>;
+export declare function generateTemplate<T extends TemplateKey>(key: T, templateOptions: TemplateOptions[T], _generateOptions?: GenerateOptions): Promise<AbsolutePath[]>;
 /**
  * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.
  * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.

package/dist/syncer/code-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/syncer/code-generator.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,WAAW,EACX,WAAW,EACX,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAWxB,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,WAAW,EAChB,eAAe,EAAE,GAAG,EACpB,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC,CA2CzB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClE,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC,CAkBxB"}
+{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/syncer/code-generator.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAMjG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAC1D,GAAG,EAAE,CAAC,EACN,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC,EACnC,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC,CAyCzB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClE,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC,CAoBxB"}

package/dist/syncer/code-generator.js

@@ -1,15 +1,17 @@
+import chalk from "chalk";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
+import { unique } from "radashi";
 import { Sonamu } from "../api/sonamu.js";
+import { EntityManager } from "../entity/entity-manager.js";
 import { AlreadyProcessedException } from "../exceptions/so-exceptions.js";
+import { Naite } from "../naite/naite.js";
+import { TemplateManager } from "../template/template-manager.js";
 import { everyAsync, filterAsync } from "../utils/async-utils.js";
+import { isTest } from "../utils/controller.js";
+import { formatCode } from "../utils/formatter.js";
 import { exists } from "../utils/fs-utils.js";
-import chalk from "chalk";
-import { mkdir, writeFile } from "node:fs/promises";
-import * as _ from "lodash-es";
-import { Template } from "../template/template.js";
-import { EntityManager } from "../entity/entity-manager.js";
 import { wrapIf } from "../utils/lodash-able.js";
-import prettier from "prettier";
 /**
  * 템플릿을 렌더링하고 파일로 생성합니다.
  * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
@@ -22,6 +24,11 @@ import prettier from "prettier";
         overwrite: false,
         ..._generateOptions
     };
+    Naite.t("generateTemplate", {
+        key,
+        templateOptions,
+        generateOptions
+    });
     // 키 children
     const keys = [
         key
@@ -54,7 +61,11 @@ import prettier from "prettier";
  * @param options - 템플릿 렌더링 옵션
  * @returns 경로와 코드 쌍의 배열
  */ export async function renderTemplate(key, options) {
-    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);
     let preTemplateResolved = [];
@@ -69,6 +80,10 @@ import prettier from "prettier";
     ];
 }
 async function resolveRenderedTemplate(key, result) {
+    Naite.t(`resolveRenderedTemplate${key}`, {
+        key,
+        result
+    });
     const { target, path: filePath, body, importKeys, customHeaders } = result;
     // import 할 대상의 대상 path 추출
     const importDefs = importKeys.reduce((r, importKey)=>{
@@ -77,13 +92,13 @@ async function resolveRenderedTemplate(key, result) {
         if (modulePath.includes("/") || modulePath.includes(".")) {
             importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p)=>[
                     p.startsWith(".") === false,
-                    "./" + p
+                    `./${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: [
@@ -94,7 +109,7 @@ async function resolveRenderedTemplate(key, result) {
         }
         return r;
     }, [])// 셀프 참조 방지
-    .filter((importDef)=>filePath.endsWith(importDef.from.replace("./", "") + ".ts") === false);
+    .filter((importDef)=>filePath.endsWith(`${importDef.from.replace("./", "")}.ts`) === false);
     // 커스텀 헤더 포함하여 헤더 생성
     const header = [
         ...customHeaders ?? [],
@@ -107,16 +122,21 @@ async function resolveRenderedTemplate(key, result) {
                 body
             ].join("\n\n");
         } else {
-            return prettier.format([
+            Naite.t("resolveRenderedTemplate:beforeFormat", {
+                key,
                 header,
                 body
-            ].join("\n\n"), {
-                parser: key === "entity" ? "json" : "typescript"
             });
+            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
     };
 }
@@ -124,7 +144,7 @@ async function writeCodeToPathEachTarget(pathAndCode) {
     const { targets } = Sonamu.config.sync;
     const { appRootPath } = Sonamu;
     const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
-    const dstFilePaths = _.uniq(targets.map((target)=>filePath.replace("/:target/", `/${target}/`)));
+    const dstFilePaths = unique(targets.map((target)=>filePath.replace("/:target/", `/${target}/`)));
     return await Promise.all(dstFilePaths.map(async (dstFilePath)=>{
         const dir = path.dirname(dstFilePath);
         if (!await exists(dir)) {
@@ -133,9 +153,9 @@ async function writeCodeToPathEachTarget(pathAndCode) {
             });
         }
         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;
     }));
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import path from \"path\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport {\n  GenerateOptions,\n  PathAndCode,\n  TemplateKey,\n  TemplateOptions,\n} from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport chalk from \"chalk\";\nimport { mkdir, writeFile } from \"fs/promises\";\nimport * as _ from \"lodash-es\";\nimport { Template } from \"../template/template\";\nimport { RenderedTemplate } from \"../template/template\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport prettier from \"prettier\";\nimport { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate(\n  key: TemplateKey,\n  templateOptions: any,\n  _generateOptions?: GenerateOptions\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      })\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite === true) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) =>\n          filePath.replace(\"/:target/\", `/${target}/`)\n        );\n        return await everyAsync(\n          dstFilePaths,\n          async (dstPath) => !(await exists(dstPath))\n        );\n      });\n    }\n  })();\n  \n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(\"이미 경로에 모든 파일이 존재합니다.\");\n  }\n\n  return (await Promise.all(\n    filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode))\n  )).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T]\n): Promise<PathAndCode[]> {\n  const template = Template.find(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        })\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate\n): Promise<PathAndCode> {\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const importDefs = importKeys\n    .reduce(\n      (r, importKey) => {\n        const modulePath = EntityManager.getModulePath(importKey);\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(\n            path.relative(path.dirname(filePath), modulePath),\n            (p) => [p.startsWith(\".\") === false, \"./\" + p]\n          );\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = _.uniq(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[]\n    )\n    // 셀프 참조 방지\n    .filter(\n      (importDef) =>\n        filePath.endsWith(importDef.from.replace(\"./\", \"\") + \".ts\") === false\n    );\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) =>\n        `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      return prettier.format([header, body].join(\"\\n\\n\"), {\n        parser: key === \"entity\" ? \"json\" : \"typescript\",\n      });\n    }\n  })();\n\n  return {\n    path: target + \"/\" + filePath,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(\n  pathAndCode: PathAndCode\n): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = _.uniq(\n    targets.map((target) =>\n      filePath.replace(\"/:target/\", `/${target}/`)\n    ) as AbsolutePath[]\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      console.log(\n        chalk.bold(\"Generated: \") +\n          chalk.blue(`${dstFilePath.replace(appRootPath + \"/\", \"\")}`)\n      );\n      return dstFilePath;\n    })\n  );\n}\n"],"names":["path","Sonamu","AlreadyProcessedException","everyAsync","filterAsync","exists","chalk","mkdir","writeFile","_","Template","EntityManager","wrapIf","prettier","generateTemplate","key","templateOptions","_generateOptions","generateOptions","overwrite","keys","pathAndCodes","Promise","all","map","renderTemplate","flat","filteredPathAndCodes","pathAndCode","targets","config","sync","filePath","appRootPath","dstFilePaths","target","replace","dstPath","length","writeCodeToPathEachTarget","options","template","find","rendered","render","resolved","resolveRenderedTemplate","preTemplateResolved","preTemplates","result","body","importKeys","customHeaders","importDefs","reduce","r","importKey","modulePath","getModulePath","importPath","includes","relative","dirname","p","startsWith","existsOne","importDef","from","uniq","concat","push","filter","endsWith","header","join","formatted","format","parser","code","dstFilePath","dir","recursive","console","log","bold","blue"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\nimport { unique } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport type { RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport type { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite === true) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(\"이미 경로에 모든 파일이 존재합니다.\");\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const importDefs = importKeys\n    .reduce(\n      (r, importKey) => {\n        const modulePath = EntityManager.getModulePath(importKey);\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            p.startsWith(\".\") === false,\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`) === false);\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = formatCode(\n        [header, body].join(\"\\n\\n\"),\n        key === \"entity\" ? \"json\" : \"typescript\",\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"names":["chalk","mkdir","writeFile","path","unique","Sonamu","EntityManager","AlreadyProcessedException","Naite","TemplateManager","everyAsync","filterAsync","isTest","formatCode","exists","wrapIf","generateTemplate","key","templateOptions","_generateOptions","generateOptions","overwrite","t","keys","pathAndCodes","Promise","all","map","renderTemplate","flat","filteredPathAndCodes","pathAndCode","targets","config","sync","filePath","appRootPath","dstFilePaths","target","replace","dstPath","length","writeCodeToPathEachTarget","options","template","get","rendered","render","resolved","resolveRenderedTemplate","preTemplateResolved","preTemplates","result","body","importKeys","customHeaders","importDefs","reduce","r","importKey","modulePath","getModulePath","importPath","includes","relative","dirname","p","startsWith","existsOne","find","importDef","from","concat","push","filter","endsWith","header","join","formatted","code","dstFilePath","dir","recursive","console","log","bold","blue"],"mappings":"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"}

package/dist/syncer/entity-operations.d.ts

@@ -1,10 +1,10 @@
-import { TemplateOptions } from "../types/types";
+import type { TemplateOptions } from "../types/types";
 /**
  * 새로운 엔티티를 생성합니다.
  * entityId는 반드시 CamelCase 형식이어야 합니다.
  */
 export declare function createEntity(form: Omit<TemplateOptions["entity"], "title"> & {
-    title?: string;
+    title: string;
 }): Promise<void>;
 /**
  * 엔티티를 삭제합니다.

package/dist/syncer/entity-operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-operations.d.ts","sourceRoot":"","sources":["../../src/syncer/entity-operations.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,iBAUpE;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAkCjC"}
+{"version":3,"file":"entity-operations.d.ts","sourceRoot":"","sources":["../../src/syncer/entity-operations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKtD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,iBAUnE;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAgCjF"}