sonamu 0.8.26 → 0.9.0

package/dist/syncer/api-parser.js

@@ -1,256 +1,235 @@
-import assert from "assert";
-import { readFile } from "node:fs/promises";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { init_decorators, registeredApis } from "../api/decorators.js";
+import { init_validator, validateMethodName } from "../api/validator.js";
 import inflection from "inflection";
+import assert from "assert";
+import { readFile } from "fs/promises";
 import ts from "typescript";
-import { registeredApis } from "../api/decorators.js";
-import { validateMethodName } from "../api/validator.js";
+
+//#region src/syncer/api-parser.ts
 /**
- * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
- * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
- * @param filePath - 파싱할 TypeScript 파일의 절대 경로
- * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
- */ export async function readApisFromFile(filePath) {
-    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 = [];
-    let modelName = "UnknownModel";
-    let methodName = "unknownMethod";
-    const visitor = (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 = (node.typeParameters ?? []).map((typeParam)=>{
-                const tp = typeParam;
-                return {
-                    t: "type-param",
-                    id: tp.name.escapedText.toString(),
-                    constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined
-                };
-            });
-            const parameters = node.parameters.map((paramDec, index)=>{
-                const defaultDef = printNode(paramDec.initializer, sourceFile);
-                // 기본값이 있는 경우 paramDec.type가 undefined로 나옴
-                return resolveParamDec({
-                    name: paramDec.name,
-                    type: paramDec.type,
-                    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}`);
-        return [];
-    }
-    // 등록된 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;
+* TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
+* @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
+* @param filePath - 파싱할 TypeScript 파일의 절대 경로
+* @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
+*/
+async function readApisFromFile(filePath) {
+	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 = [];
+	let modelName = "UnknownModel";
+	let methodName = "unknownMethod";
+	const visitor = (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 = (node.typeParameters ?? []).map((typeParam) => {
+				const tp = typeParam;
+				return {
+					t: "type-param",
+					id: tp.name.escapedText.toString(),
+					constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined
+				};
+			});
+			const parameters = node.parameters.map((paramDec, index) => {
+				const defaultDef = printNode(paramDec.initializer, sourceFile);
+				return resolveParamDec({
+					name: paramDec.name,
+					type: paramDec.type,
+					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 [];
+	}
+	const currentModelApis = registeredApis.filter((api) => {
+		return methods.find((method) => method.modelName === api.modelName && method.methodName === api.methodName);
+	});
+	if (currentModelApis.length === 0) {
+		return [];
+	}
+	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) {
-    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.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: "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",
-                id: typeNode.typeName.escapedText.toString(),
-                args: typeNode.typeArguments?.map((typeArg)=>resolveTypeNode(typeArg))
-            };
-        case ts.SyntaxKind.UnionType:
-            return {
-                t: "union",
-                types: typeNode.types.map((type)=>resolveTypeNode(type))
-            };
-        case ts.SyntaxKind.IntersectionType:
-            return {
-                t: "intersection",
-                types: typeNode.types.map((type)=>resolveTypeNode(type))
-            };
-        case ts.SyntaxKind.IndexedAccessType:
-            return {
-                t: "indexed-access",
-                object: resolveTypeNode(typeNode.objectType),
-                index: resolveTypeNode(typeNode.indexType)
-            };
-        case ts.SyntaxKind.TupleType:
-            if (ts.isTupleTypeNode(typeNode)) {
-                return {
-                    t: "tuple-type",
-                    elements: typeNode.elements.map((elem)=>resolveTypeNode(elem))
-                };
-            }
-            break;
-        case ts.SyntaxKind.ParenthesizedType:
-            // 괄호로 묶인 타입 (예: (A & B)[] 에서 (A & B))
-            // 내부 타입을 재귀적으로 resolve
-            return resolveTypeNode(typeNode.type);
-        case ts.SyntaxKind.FunctionType:
-            return {
-                t: "function",
-                parameters: typeNode.parameters.map((param)=>({
-                        name: param.name.getText(),
-                        type: param.type ? resolveTypeNode(param.type) : "unknown",
-                        optional: param.questionToken !== undefined,
-                        defaultDef: undefined
-                    })),
-                returnType: resolveTypeNode(typeNode.type)
-            };
-        case undefined:
-            throw new Error(`typeNode undefined`);
-    }
-    console.debug(typeNode);
-    throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);
+	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.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: "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",
+			id: typeNode.typeName.escapedText.toString(),
+			args: typeNode.typeArguments?.map((typeArg) => resolveTypeNode(typeArg))
+		};
+		case ts.SyntaxKind.UnionType: return {
+			t: "union",
+			types: typeNode.types.map((type) => resolveTypeNode(type))
+		};
+		case ts.SyntaxKind.IntersectionType: return {
+			t: "intersection",
+			types: typeNode.types.map((type) => resolveTypeNode(type))
+		};
+		case ts.SyntaxKind.IndexedAccessType: return {
+			t: "indexed-access",
+			object: resolveTypeNode(typeNode.objectType),
+			index: resolveTypeNode(typeNode.indexType)
+		};
+		case ts.SyntaxKind.TupleType:
+			if (ts.isTupleTypeNode(typeNode)) {
+				return {
+					t: "tuple-type",
+					elements: typeNode.elements.map((elem) => resolveTypeNode(elem))
+				};
+			}
+			break;
+		case ts.SyntaxKind.ParenthesizedType: return resolveTypeNode(typeNode.type);
+		case ts.SyntaxKind.FunctionType: return {
+			t: "function",
+			parameters: typeNode.parameters.map((param) => ({
+				name: param.name.getText(),
+				type: param.type ? resolveTypeNode(param.type) : "unknown",
+				optional: param.questionToken !== undefined,
+				defaultDef: undefined
+			})),
+			returnType: resolveTypeNode(typeNode.type)
+		};
+		case undefined: throw new Error(`typeNode undefined`);
+	}
+	console.debug(typeNode);
+	throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);
 }
 function resolveParamDec(paramDec, index = 0) {
-    const name = paramDec.name;
-    const type = resolveTypeNode(paramDec.type);
-    if (name === undefined) {
-        console.debug({
-            name,
-            type,
-            paramDec
-        });
-    }
-    const result = {
-        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;
+	const name = paramDec.name;
+	const type = resolveTypeNode(paramDec.type);
+	if (name === undefined) {
+		console.debug({
+			name,
+			type,
+			paramDec
+		});
+	}
+	const result = {
+		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, sourceFile) {
-    if (node === undefined) {
-        return undefined;
-    }
-    const printer = ts.createPrinter({
-        newLine: ts.NewLineKind.LineFeed
-    });
-    return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+	if (node === undefined) {
+		return undefined;
+	}
+	const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+	return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
 }
+var init_api_parser = __esmMin((() => {
+	init_decorators();
+	init_validator();
+}));
 
-//# 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    return [];\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 ts.SyntaxKind.ParenthesizedType:\n      // 괄호로 묶인 타입 (예: (A & B)[] 에서 (A & B))\n      // 내부 타입을 재귀적으로 resolve\n      return resolveTypeNode((typeNode as ts.ParenthesizedTypeNode).type);\n\n    case ts.SyntaxKind.FunctionType:\n      return {\n        t: \"function\",\n        parameters: (typeNode as ts.FunctionTypeNode).parameters.map((param) => ({\n          name: param.name.getText(),\n          type: param.type ? resolveTypeNode(param.type) : \"unknown\",\n          optional: param.questionToken !== undefined,\n          defaultDef: undefined,\n        })),\n        returnType: resolveTypeNode((typeNode as ts.FunctionTypeNode).type),\n      };\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","ParenthesizedType","FunctionType","param","getText","console","debug","result","isObjectBindingPattern","isTypeReferenceNode","camelize","printer","createPrinter","newLine","NewLineKind","LineFeed","EmitHint","Unspecified"],"mappings":"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"}
+//#endregion
+init_api_parser();
+export { init_api_parser, readApisFromFile };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"api-parser.js","names":["methods: Omit<ExtendedApi, \"path\" | \"options\">[]","modelName: string","methodName: string","typeParameters: ApiParamType.TypeParam[]","parameters: ApiParam[]","result: ApiParam"],"sources":["../../src/syncer/api-parser.ts"],"sourcesContent":["import assert from \"assert\";\nimport { readFile } from \"fs/promises\";\n\nimport inflection from \"inflection\";\nimport ts from \"typescript\";\n\nimport { registeredApis } from \"../api/decorators\";\nimport { type ExtendedApi } from \"../api/decorators\";\nimport { validateMethodName } from \"../api/validator\";\nimport { type ApiParam, type 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;\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    return [];\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,\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 ts.SyntaxKind.ParenthesizedType:\n      // 괄호로 묶인 타입 (예: (A & B)[] 에서 (A & B))\n      // 내부 타입을 재귀적으로 resolve\n      return resolveTypeNode((typeNode as ts.ParenthesizedTypeNode).type);\n\n    case ts.SyntaxKind.FunctionType:\n      return {\n        t: \"function\",\n        parameters: (typeNode as ts.FunctionTypeNode).parameters.map((param) => ({\n          name: param.name.getText(),\n          type: param.type ? resolveTypeNode(param.type) : \"unknown\",\n          optional: param.questionToken !== undefined,\n          defaultDef: undefined,\n        })),\n        returnType: resolveTypeNode((typeNode as ts.FunctionTypeNode).type),\n      };\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"],"mappings":"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"}

package/dist/syncer/checksum.d.ts

@@ -1,4 +1,4 @@
-import type { AbsolutePath } from "../utils/path-utils";
+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":"AASA,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"}
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,qBAAqB,CAAC;AAS9E;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAU9E;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD"}