sonamu 0.11.16 → 0.13.0

package/dist/syncer/module-loader.js

@@ -7,14 +7,15 @@ import { init_path_utils, runtimePath } from "../utils/path-utils.js";
 import { init_api_parser, readApisFromFile } from "./api-parser.js";
 import { z } from "zod";
 import path from "path";
-//#region src/syncer/module-loader.ts
+// src/syncer/module-loader.ts
 /**
 * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.
 * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.
 * 따라서 loadModels()를 먼저 호출해야 합니다.
 */
 async function loadApis() {
-	const modelPaths = await globAsync(path.join(Sonamu.apiRootPath, "src/application/**/*.{model,frame}.ts"));
+	const modelPathsPattern = path.join(Sonamu.apiRootPath, "src/application/**/*.{model,frame}.ts");
+	const modelPaths = await globAsync(modelPathsPattern);
 	const apis = [];
 	for (const filePath of modelPaths) {
 		const parsedApis = await readApisFromFile(filePath);
@@ -27,7 +28,8 @@ async function loadApis() {
 * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.
 */
 async function loadModels() {
-	const modelPaths = await globAsync(path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.{model,frame}.ts")));
+	const modelPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.{model,frame}.ts"));
+	const modelPaths = await globAsync(modelPathsPattern);
 	const models = {};
 	for (const filePath of modelPaths) {
 		const importedMembers = await importMembers(filePath);
@@ -52,7 +54,8 @@ async function loadTypes() {
 * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.
 */
 async function loadWorkflows() {
-	const workflowPaths = await globAsync(path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.workflow.ts")));
+	const workflowPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.workflow.ts"));
+	const workflowPaths = await globAsync(workflowPathsPattern);
 	const workflows = /* @__PURE__ */ new Map();
 	for (const filePath of workflowPaths) {
 		const importedMembers = await importMembers(filePath);
@@ -72,8 +75,7 @@ var init_module_loader = __esmMin((() => {
 	init_runtime_value();
 	init_api_parser();
 }));
-//#endregion
 init_module_loader();
 export { init_module_loader, loadApis, loadModels, loadTypes, loadWorkflows };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"module-loader.js","names":[],"sources":["../../src/syncer/module-loader.ts"],"sourcesContent":["import path from \"path\";\n\nimport { z } from \"zod\";\n\nimport { type BaseFrameClass } from \"../api/base-frame\";\nimport { type ExtendedApi } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type BaseModelClass } from \"../database/base-model\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { importMembers } from \"../utils/esm-utils\";\nimport { runtimePath } from \"../utils/path-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { isFunctionValue, isObjectValue } from \"../utils/runtime-value\";\nimport { readApisFromFile } from \"./api-parser\";\n\nexport type LoadedApis = ExtendedApi[];\n\nexport type LoadedTypes = { [typeName: string]: z.ZodType };\n\nexport type LoadedModels = {\n  [modelName: string]: BaseModelClass | BaseFrameClass;\n};\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.\n * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.\n * 따라서 loadModels()를 먼저 호출해야 합니다.\n */\nexport async function loadApis(): Promise<LoadedApis> {\n  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,\n  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.\n  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.\n  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    \"src/application/**/*.{model,frame}.ts\", // !! runtimePath 안 씀 주의 !!\n  );\n  const modelPaths =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (await globAsync(\n      modelPathsPattern,\n    )) as AbsolutePath[];\n\n  const apis: LoadedApis = [];\n  for (const filePath of modelPaths) {\n    const parsedApis = await readApisFromFile(filePath);\n    apis.push(...parsedApis);\n  }\n  // console.log(\n  //   chalk.gray(`[Loading] Loaded APIs from \"*.model.ts\" files: ${count} files.`)\n  // );\n\n  for (const api of apis) {\n    if (api.path === \"\") {\n      // api의 경로(path)가 \"텅 비어있음\"인 상태입니다.\n      // 이는 @api와 함께 사용해야 하는 데코레이터가 @api 없이 붙은 상황입니다.\n      throw new Error(\n        `API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`,\n      );\n    }\n  }\n\n  return apis;\n}\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.\n */\nexport async function loadModels(): Promise<LoadedModels> {\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.{model,frame}.ts\"),\n  );\n  const modelPaths = await globAsync(modelPathsPattern);\n\n  const models: LoadedModels = {};\n  for (const filePath of modelPaths) {\n    const importedMembers = await importMembers<BaseModelClass | BaseFrameClass>(filePath);\n\n    for (const { name, value } of importedMembers) {\n      if (name.endsWith(\"Model\") || name.endsWith(\"Frame\")) {\n        models[name] = value;\n      }\n    }\n  }\n\n  return models;\n}\n\n/**\n * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.\n */\nexport async function loadTypes(): Promise<LoadedTypes> {\n  const typePathsPatterns = [\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.types.ts\")),\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.generated.ts\")),\n  ];\n  const typePaths = (\n    await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))\n  ).flat();\n\n  const types: LoadedTypes = {};\n  for (const filePath of typePaths) {\n    const importedMembers = await importMembers<z.ZodType>(filePath);\n    for (const { name, value } of importedMembers) {\n      if (value instanceof z.ZodType) {\n        types[name] = value;\n      }\n    }\n  }\n\n  return types;\n}\n\n/**\n * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.\n */\nexport async function loadWorkflows() {\n  const workflowPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.workflow.ts\"),\n  );\n  const workflowPaths = await globAsync(workflowPathsPattern);\n  const workflows: Map<string, WorkflowMetadata[]> = new Map();\n  for (const filePath of workflowPaths) {\n    const importedMembers = await importMembers(filePath);\n    workflows.set(\n      filePath,\n      importedMembers\n        .filter(({ value }) => {\n          return (\n            isObjectValue(value) &&\n            value !== null &&\n            \"type\" in value &&\n            value.type === \"workflow\" &&\n            \"fn\" in value &&\n            isFunctionValue(value.fn)\n          );\n        })\n        .map(({ value }) => {\n          return /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ value as WorkflowMetadata;\n        }),\n    );\n  }\n\n  return workflows;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA6BA,eAAsB,WAAgC;CASpD,MAAM,aACwD,MAAM,UAL1C,KAAK,KAC7B,OAAO,aACP,uCAIE,CACF;CAEF,MAAM,OAAmB,CAAC;CAC1B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,aAAa,MAAM,iBAAiB,QAAQ;EAClD,KAAK,KAAK,GAAG,UAAU;CACzB;CAKA,KAAK,MAAM,OAAO,MAChB,IAAI,IAAI,SAAS,IAGf,MAAM,IAAI,MACR,OAAO,IAAI,UAAU,GAAG,IAAI,WAAW,0DACzC;CAIJ,OAAO;AACT;;;;AAKA,eAAsB,aAAoC;CAKxD,MAAM,aAAa,MAAM,UAJC,KAAK,KAC7B,OAAO,aACP,YAAY,uCAAuC,CAElB,CAAiB;CAEpD,MAAM,SAAuB,CAAC;CAC9B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,kBAAkB,MAAM,cAA+C,QAAQ;EAErF,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,KAAK,SAAS,OAAO,KAAK,KAAK,SAAS,OAAO,GACjD,OAAO,QAAQ;CAGrB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,YAAkC;CACtD,MAAM,oBAAoB,CACxB,KAAK,KAAK,OAAO,aAAa,YAAY,+BAA+B,CAAC,GAC1E,KAAK,KAAK,OAAO,aAAa,YAAY,mCAAmC,CAAC,CAChF;CACA,MAAM,aACJ,MAAM,QAAQ,IAAI,kBAAkB,KAAK,YAAY,UAAU,OAAO,CAAC,CAAC,EAAA,CACxE,KAAK;CAEP,MAAM,QAAqB,CAAC;CAC5B,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,kBAAkB,MAAM,cAAyB,QAAQ;EAC/D,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,iBAAiB,EAAE,SACrB,MAAM,QAAQ;CAGpB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,gBAAgB;CAKpC,MAAM,gBAAgB,MAAM,UAJC,KAAK,KAChC,OAAO,aACP,YAAY,kCAAkC,CAEV,CAAoB;CAC1D,MAAM,4BAA6C,IAAI,IAAI;CAC3D,KAAK,MAAM,YAAY,eAAe;EACpC,MAAM,kBAAkB,MAAM,cAAc,QAAQ;EACpD,UAAU,IACR,UACA,gBACG,QAAQ,EAAE,YAAY;GACrB,OACE,cAAc,KAAK,KACnB,UAAU,QACV,UAAU,SACV,MAAM,SAAS,cACf,QAAQ,SACR,gBAAgB,MAAM,EAAE;EAE5B,CAAC,CAAC,CACD,KAAK,EAAE,YAAY;GAClB,OAAkE;EACpE,CAAC,CACL;CACF;CAEA,OAAO;AACT;;aA5IsC;kBAGU;gBACE;iBACD;oBAEsB;iBACxB"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"module-loader.js","names":[],"sources":["../../src/syncer/module-loader.ts"],"sourcesContent":["import path from \"path\";\n\nimport { z } from \"zod\";\n\nimport { type BaseFrameClass } from \"../api/base-frame\";\nimport { type ExtendedApi } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type BaseModelClass } from \"../database/base-model\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { importMembers } from \"../utils/esm-utils\";\nimport { runtimePath } from \"../utils/path-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { isFunctionValue, isObjectValue } from \"../utils/runtime-value\";\nimport { readApisFromFile } from \"./api-parser\";\n\nexport type LoadedApis = ExtendedApi[];\n\nexport type LoadedTypes = { [typeName: string]: z.ZodType };\n\nexport type LoadedModels = {\n  [modelName: string]: BaseModelClass | BaseFrameClass;\n};\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.\n * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.\n * 따라서 loadModels()를 먼저 호출해야 합니다.\n */\nexport async function loadApis(): Promise<LoadedApis> {\n  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,\n  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.\n  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.\n  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    \"src/application/**/*.{model,frame}.ts\", // !! runtimePath 안 씀 주의 !!\n  );\n  const modelPaths =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (await globAsync(\n      modelPathsPattern,\n    )) as AbsolutePath[];\n\n  const apis: LoadedApis = [];\n  for (const filePath of modelPaths) {\n    const parsedApis = await readApisFromFile(filePath);\n    apis.push(...parsedApis);\n  }\n  // console.log(\n  //   chalk.gray(`[Loading] Loaded APIs from \"*.model.ts\" files: ${count} files.`)\n  // );\n\n  for (const api of apis) {\n    if (api.path === \"\") {\n      // api의 경로(path)가 \"텅 비어있음\"인 상태입니다.\n      // 이는 @api와 함께 사용해야 하는 데코레이터가 @api 없이 붙은 상황입니다.\n      throw new Error(\n        `API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`,\n      );\n    }\n  }\n\n  return apis;\n}\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.\n */\nexport async function loadModels(): Promise<LoadedModels> {\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.{model,frame}.ts\"),\n  );\n  const modelPaths = await globAsync(modelPathsPattern);\n\n  const models: LoadedModels = {};\n  for (const filePath of modelPaths) {\n    const importedMembers = await importMembers<BaseModelClass | BaseFrameClass>(filePath);\n\n    for (const { name, value } of importedMembers) {\n      if (name.endsWith(\"Model\") || name.endsWith(\"Frame\")) {\n        models[name] = value;\n      }\n    }\n  }\n\n  return models;\n}\n\n/**\n * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.\n */\nexport async function loadTypes(): Promise<LoadedTypes> {\n  const typePathsPatterns = [\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.types.ts\")),\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.generated.ts\")),\n  ];\n  const typePaths = (\n    await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))\n  ).flat();\n\n  const types: LoadedTypes = {};\n  for (const filePath of typePaths) {\n    const importedMembers = await importMembers<z.ZodType>(filePath);\n    for (const { name, value } of importedMembers) {\n      if (value instanceof z.ZodType) {\n        types[name] = value;\n      }\n    }\n  }\n\n  return types;\n}\n\n/**\n * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.\n */\nexport async function loadWorkflows() {\n  const workflowPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.workflow.ts\"),\n  );\n  const workflowPaths = await globAsync(workflowPathsPattern);\n  const workflows: Map<string, WorkflowMetadata[]> = new Map();\n  for (const filePath of workflowPaths) {\n    const importedMembers = await importMembers(filePath);\n    workflows.set(\n      filePath,\n      importedMembers\n        .filter(({ value }) => {\n          return (\n            isObjectValue(value) &&\n            value !== null &&\n            \"type\" in value &&\n            value.type === \"workflow\" &&\n            \"fn\" in value &&\n            isFunctionValue(value.fn)\n          );\n        })\n        .map(({ value }) => {\n          return /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ value as WorkflowMetadata;\n        }),\n    );\n  }\n\n  return workflows;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA6BA,eAAsB,WAAgC;CAKpD,MAAM,oBAAoB,KAAK,KAC7B,OAAO,aACP,uCACF;CACA,MAAM,aACwD,MAAM,UAChE,iBACF;CAEF,MAAM,OAAmB,CAAC;CAC1B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,aAAa,MAAM,iBAAiB,QAAQ;EAClD,KAAK,KAAK,GAAG,UAAU;CACzB;CAKA,KAAK,MAAM,OAAO,MAChB,IAAI,IAAI,SAAS,IAGf,MAAM,IAAI,MACR,OAAO,IAAI,UAAU,GAAG,IAAI,WAAW,0DACzC;CAIJ,OAAO;AACT;;;;AAKA,eAAsB,aAAoC;CACxD,MAAM,oBAAoB,KAAK,KAC7B,OAAO,aACP,YAAY,uCAAuC,CACrD;CACA,MAAM,aAAa,MAAM,UAAU,iBAAiB;CAEpD,MAAM,SAAuB,CAAC;CAC9B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,kBAAkB,MAAM,cAA+C,QAAQ;EAErF,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,KAAK,SAAS,OAAO,KAAK,KAAK,SAAS,OAAO,GACjD,OAAO,QAAQ;CAGrB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,YAAkC;CACtD,MAAM,oBAAoB,CACxB,KAAK,KAAK,OAAO,aAAa,YAAY,+BAA+B,CAAC,GAC1E,KAAK,KAAK,OAAO,aAAa,YAAY,mCAAmC,CAAC,CAChF;CACA,MAAM,aACJ,MAAM,QAAQ,IAAI,kBAAkB,KAAK,YAAY,UAAU,OAAO,CAAC,CAAC,EAAA,CACxE,KAAK;CAEP,MAAM,QAAqB,CAAC;CAC5B,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,kBAAkB,MAAM,cAAyB,QAAQ;EAC/D,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,iBAAiB,EAAE,SACrB,MAAM,QAAQ;CAGpB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,gBAAgB;CACpC,MAAM,uBAAuB,KAAK,KAChC,OAAO,aACP,YAAY,kCAAkC,CAChD;CACA,MAAM,gBAAgB,MAAM,UAAU,oBAAoB;CAC1D,MAAM,4BAA6C,IAAI,IAAI;CAC3D,KAAK,MAAM,YAAY,eAAe;EACpC,MAAM,kBAAkB,MAAM,cAAc,QAAQ;EACpD,UAAU,IACR,UACA,gBACG,QAAQ,EAAE,YAAY;GACrB,OACE,cAAc,KAAK,KACnB,UAAU,QACV,UAAU,SACV,MAAM,SAAS,cACf,QAAQ,SACR,gBAAgB,MAAM,EAAE;EAE5B,CAAC,CAAC,CACD,KAAK,EAAE,YAAY;GAClB,OAAkE;EACpE,CAAC,CACL;CACF;CAEA,OAAO;AACT;;CA5IsC,YAAA;CAGU,iBAAA;CACE,eAAA;CACD,gBAAA;CAEsB,mBAAA;CACxB,gBAAA"}

package/dist/syncer/syncer-actions.js

@@ -12,7 +12,7 @@ import { copyFileWithReplaceCoreToShared, init_file_copy } from "./file-copy.js"
 import assert from "assert";
 import path, { dirname } from "path";
 import chalk from "chalk";
-//#region src/syncer/syncer-actions.ts
+// src/syncer/syncer-actions.ts
 async function actionSyncConfig() {
 	const { host, port } = Sonamu.config.server.listen ?? {};
 	const content = `API_HOST=${host ?? "localhost"}\nAPI_PORT=${port ?? 3e3}`;
@@ -104,12 +104,13 @@ async function actionSyncFilesToTargets(tsPaths) {
 		const dst = realSrc.replace(`/${apiDir}/`, `/${target}/`).replace("/application/", "/services/");
 		const dir = dirname(dst);
 		if (!await syncerFileExists(dir)) await syncerFilesystem.mkdir(dir, { recursive: true });
-		await copyFileWithReplaceCoreToShared(realSrc, dst, [
+		const syncHeader = [
 			"/**",
 			" * @generated",
 			" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.",
 			" */"
-		].join("\n"));
+		].join("\n");
+		await copyFileWithReplaceCoreToShared(realSrc, dst, syncHeader);
 		await trackWritten(dst);
 		!isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, "")));
 		return dst;
@@ -175,12 +176,13 @@ async function syncLocaleFiles(target, apiI18nDir, locales) {
 	for (const locale of locales) {
 		const sourceFile = path.join(apiI18nDir, `${locale}.ts`);
 		const targetFile = path.join(targetI18nDir, `${locale}.ts`);
-		await copyFileWithReplaceCoreToShared(sourceFile, targetFile, [
+		const syncHeader = [
 			"/**",
 			" * @generated",
 			" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.",
 			" */"
-		].join("\n"));
+		].join("\n");
+		await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);
 		await trackWritten(targetFile);
 		!isTest() && console.log(chalk.bold("Copied: ") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));
 	}
@@ -197,8 +199,7 @@ var init_syncer_actions = __esmMin((() => {
 	init_file_tracking();
 	init_filesystem_dependencies();
 }));
-//#endregion
 init_syncer_actions();
 export { actionCopySharedToTargetsIfNotExists, actionGenerateHttpValidators, actionGenerateHttps, actionGenerateInitialTypes, actionGenerateSchemas, actionGenerateServices, actionGenerateSsrEntryServerIfNotExists, actionGenerateSsrQueries, actionSyncConfig, actionSyncFilesToTargets, actionSyncSonamuDictionary, init_syncer_actions };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer-actions.js","names":[],"sources":["../../src/syncer/syncer-actions.ts"],"sourcesContent":["import assert from \"assert\";\nimport path, { dirname } from \"path\";\n\nimport chalk from \"chalk\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { formatCode } from \"../code-formatting\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { isTest } from \"../utils/controller\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { isObjectValue } from \"../utils/runtime-value\";\nimport { generateTemplate } from \"./code-generator\";\nimport { copyFileWithReplaceCoreToShared } from \"./file-copy\";\nimport { trackWritten } from \"./file-tracking\";\nimport { syncerFileExists, syncerFilesystem } from \"./filesystem-dependencies\";\n\n// web/.sonamu.env 에 현재 설정값 저장\nexport async function actionSyncConfig() {\n  const { host, port } = Sonamu.config.server.listen ?? {};\n  const content = `API_HOST=${host ?? \"localhost\"}\\nAPI_PORT=${port ?? 3000}`;\n\n  Naite.t(\"actionSyncConfig\", { content });\n  await Promise.all([\n    ...Sonamu.config.sync.targets.map((target) => {\n      return syncerFilesystem.writeFile(\n        path.join(Sonamu.appRootPath, target, \".sonamu.env\"),\n        content,\n      );\n    }),\n    generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n  ]);\n}\n\n/**\n * services.generated.ts를 생성합니다.\n * @param paramsArray\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateServices(\n  paramsArray: {\n    namesRecord: EntityNamesRecord;\n  }[],\n): Promise<AbsolutePath[]> {\n  Naite.t(\"actionGenerateServices\", paramsArray);\n\n  // services.generated.ts 통합 파일 생성\n  const servicesFile = await generateTemplate(\n    \"services\",\n    {},\n    {\n      overwrite: true,\n    },\n  );\n\n  return [...servicesFile];\n}\n\n/**\n * Entity에 딸린 초기 types.ts를 만들어줍니다.\n * @param entityId\n */\nexport async function actionGenerateInitialTypes(entityId: string): Promise<AbsolutePath[]> {\n  return generateTemplate(\"init_types\", { entityId });\n}\n\n/**\n * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSchemas(): Promise<AbsolutePath[]> {\n  return (\n    await Promise.all([\n      generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n      generateTemplate(\"generated\", {}, { overwrite: true }),\n    ])\n  ).flat();\n}\n\n/**\n * sonamu.generated.http를 생성합니다.\n * @returns 생성된 파일 경로.\n */\nexport async function actionGenerateHttps(): Promise<AbsolutePath> {\n  const [res] = await generateTemplate(\n    \"generated_http\",\n    { entityId: \"dummy\" },\n    { overwrite: true },\n  );\n  assert(res);\n  return res;\n}\n\n/**\n * 최종 REST caster를 담는 API 전용 validator registry를 재생성합니다.\n */\nexport async function actionGenerateHttpValidators(): Promise<AbsolutePath> {\n  const registryPath =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ path.join(\n      Sonamu.apiRootPath,\n      \"src/application/sonamu.validators.generated.ts\",\n    ) as AbsolutePath;\n  const policy = Sonamu.config.validation?.zodCompiler;\n  const isAot = isObjectValue(policy) && policy !== null && policy.api === \"aot\";\n  if (!isAot) {\n    // opt-out/JIT 전환 뒤 AOT compile import가 애플리케이션에 남지 않도록 산출물도 함께 정리합니다.\n    if (await syncerFileExists(registryPath)) {\n      await syncerFilesystem.unlink(registryPath);\n    }\n    return registryPath;\n  }\n\n  const [generatedPath] = await generateTemplate(\"http_validators\", {}, { overwrite: true });\n  assert(generatedPath);\n  return generatedPath;\n}\n\n/**\n * queries.generated.ts 재생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSsrQueries(): Promise<AbsolutePath[]> {\n  return generateTemplate(\"queries\", {}, { overwrite: true });\n}\n\n/**\n * entry-server.generated.tsx를 생성합니다.\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n * 입력 의존 없는 정적 코드라 매번 overwrite는 mtime만 갱신하는 의미 없는 동작.\n * 템플릿 자체가 변경된 경우(Sonamu 업그레이드)에는 사용자가 파일을 삭제한 뒤 sync로 재생성.\n * @returns 생성된 파일 경로 배열 (이미 있으면 빈 배열).\n */\nexport async function actionGenerateSsrEntryServerIfNotExists(): Promise<AbsolutePath[]> {\n  try {\n    return await generateTemplate(\"entry_server\", {}, { overwrite: false });\n  } catch (e) {\n    // generateTemplate은 overwrite: false에서 파일이 이미 있으면 예외를 던집니다.\n    // IfNotExists 의미상 \"그냥 놔둔다\"가 정상이므로 빈 배열로 변환합니다.\n    if (e instanceof AlreadyProcessedException) {\n      return [];\n    }\n    throw e;\n  }\n}\n\n/**\n * 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.\n * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,\n * 경로의 /application/은 /services/로 치환됩니다.\n *\n * @param tsPaths 복사할 파일들의 절대 경로\n * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).\n */\nexport async function actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]> {\n  const { targets } = Sonamu.config.sync;\n  const { dir: apiDir } = Sonamu.config.api;\n\n  return (\n    await Promise.all(\n      targets.map(async (target) =>\n        Promise.all(\n          tsPaths.map(async (realSrc) => {\n            const dst = realSrc\n              .replace(`/${apiDir}/`, `/${target}/`)\n              .replace(\"/application/\", \"/services/\");\n            const dir = dirname(dst);\n            if (!(await syncerFileExists(dir))) {\n              await syncerFilesystem.mkdir(dir, { recursive: true });\n            }\n            const syncHeader = [\n              \"/**\",\n              \" * @generated\",\n              \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n              \" */\",\n            ].join(\"\\n\");\n            await copyFileWithReplaceCoreToShared(realSrc, dst, syncHeader);\n            await trackWritten(\n              /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ dst as AbsolutePath,\n            );\n            !isTest() &&\n              console.log(\n                chalk.bold(\"Copied: \") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, \"\")),\n              );\n            return dst;\n          }),\n        ),\n      ),\n    )\n  ).flat();\n}\n\n/**\n * shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.\n * 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.\n *\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n */\nexport async function actionCopySharedToTargetsIfNotExists(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n\n  // plural.ts 내용을 읽어서 shared 파일에 삽입합니다.\n  const dictUtilsPath = path.join(\n    import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n    \"../dict/utils.ts\",\n  );\n  const dictUtilsCode = (await syncerFileExists(dictUtilsPath))\n    ? await syncerFilesystem.readFile(dictUtilsPath, \"utf-8\")\n    : \"\";\n\n  // 특정 변수 치환을 위해서 사용합니다.\n  const convertMap = {\n    baseUrl:\n      Sonamu.config.server.baseUrl ??\n      `http://${Sonamu.config.server.listen?.host ?? \"localhost\"}:${Sonamu.config.server.listen?.port ?? 3000}`,\n    dictUtils: dictUtilsCode,\n  };\n\n  for (const target of targets) {\n    // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.\n    // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.\n    // 따라서 /src/에서 찾습니다.\n    const srcPath = path.join(\n      import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n      `../shared/${target}.shared.ts.txt`,\n    );\n    if (!(await syncerFileExists(srcPath))) {\n      continue;\n    }\n    if (!(await syncerFileExists(path.join(Sonamu.appRootPath, target)))) {\n      throw new Error(\n        `Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`,\n      );\n    }\n\n    const fullText = await syncerFilesystem.readFile(srcPath, \"utf-8\");\n    const convertedText = Object.entries(convertMap).reduce(\n      (acc, [key, value]) => acc.replace(`$[[${key}]]`, value),\n      fullText,\n    );\n\n    // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.\n    const destPath = path.join(Sonamu.appRootPath, target, \"src/services/sonamu.shared.ts\");\n\n    // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.\n    if (!(await syncerFileExists(path.dirname(destPath)))) {\n      await syncerFilesystem.mkdir(path.dirname(destPath), { recursive: true });\n      console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);\n    }\n\n    // 파일이 이미 존재하면 건너뜁니다.\n    // sonamu.shared.ts는 프로젝트에서 자유롭게 커스터마이징할 수 있어야 하므로,\n    // 최초 1회만 생성하고 이후에는 덮어쓰지 않습니다.\n    // 템플릿 내용($[[dictUtils]] 등)이 변경되었을 때 반영이 필요하면,\n    // 해당 파일을 삭제한 뒤 `pnpm sonamu sync`로 재생성하면 됩니다.\n    if (await syncerFileExists(destPath)) {\n      continue;\n    }\n\n    await syncerFilesystem.writeFile(destPath, await formatCode(convertedText, destPath));\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));\n  }\n}\n\n/**\n * Sonamu Dictionary(SD)를 모든 타겟(api + web/app 등)에 동기화합니다.\n *\n * 각 타겟에 대해:\n * - target이 api가 아니면 사용자 작성 locale 파일(ko.ts/en.ts/...)을 api → target으로 복사\n * - sd 템플릿을 렌더링해서 sd.generated.ts 생성 (overwrite)\n *\n * 한 타겟에서 실패해도 다른 타겟은 계속 진행합니다.\n */\nexport async function actionSyncSonamuDictionary(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n  const i18nConfig = Sonamu.config.i18n;\n\n  const targetList =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ [\n      \"api\",\n      ...targets,\n    ] as (\"api\" | \"web\" | \"app\")[];\n\n  const apiI18nDir = path.join(Sonamu.appRootPath, Sonamu.config.api.dir, \"src/i18n\");\n\n  for (const target of targetList) {\n    try {\n      // web/app의 경우 locale 파일들을 api에서 복사\n      if (target !== \"api\") {\n        await syncLocaleFiles(target, apiI18nDir, i18nConfig.supportedLocales);\n      }\n\n      await generateTemplate(\"sd\", { target }, { overwrite: true });\n    } catch (e) {\n      console.error(`Failed to generate SD template for ${target}:`, e);\n    }\n  }\n}\n\n/**\n * api의 locale 파일을 web/app으로 복사합니다.\n */\nasync function syncLocaleFiles(\n  target: string,\n  apiI18nDir: string,\n  locales: string[],\n): Promise<void> {\n  const targetI18nDir = path.join(Sonamu.appRootPath, target, \"src/i18n\");\n\n  // 디렉토리가 없으면 생성\n  await syncerFilesystem.mkdir(targetI18nDir, { recursive: true });\n\n  for (const locale of locales) {\n    const sourceFile = path.join(apiI18nDir, `${locale}.ts`);\n    const targetFile = path.join(targetI18nDir, `${locale}.ts`);\n\n    const syncHeader = [\n      \"/**\",\n      \" * @generated\",\n      \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n      \" */\",\n    ].join(\"\\n\");\n    await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);\n    await trackWritten(\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ targetFile as AbsolutePath,\n    );\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer-actions.js","names":[],"sources":["../../src/syncer/syncer-actions.ts"],"sourcesContent":["import assert from \"assert\";\nimport path, { dirname } from \"path\";\n\nimport chalk from \"chalk\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { formatCode } from \"../code-formatting\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { isTest } from \"../utils/controller\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { isObjectValue } from \"../utils/runtime-value\";\nimport { generateTemplate } from \"./code-generator\";\nimport { copyFileWithReplaceCoreToShared } from \"./file-copy\";\nimport { trackWritten } from \"./file-tracking\";\nimport { syncerFileExists, syncerFilesystem } from \"./filesystem-dependencies\";\n\n// web/.sonamu.env 에 현재 설정값 저장\nexport async function actionSyncConfig() {\n  const { host, port } = Sonamu.config.server.listen ?? {};\n  const content = `API_HOST=${host ?? \"localhost\"}\\nAPI_PORT=${port ?? 3000}`;\n\n  Naite.t(\"actionSyncConfig\", { content });\n  await Promise.all([\n    ...Sonamu.config.sync.targets.map((target) => {\n      return syncerFilesystem.writeFile(\n        path.join(Sonamu.appRootPath, target, \".sonamu.env\"),\n        content,\n      );\n    }),\n    generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n  ]);\n}\n\n/**\n * services.generated.ts를 생성합니다.\n * @param paramsArray\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateServices(\n  paramsArray: {\n    namesRecord: EntityNamesRecord;\n  }[],\n): Promise<AbsolutePath[]> {\n  Naite.t(\"actionGenerateServices\", paramsArray);\n\n  // services.generated.ts 통합 파일 생성\n  const servicesFile = await generateTemplate(\n    \"services\",\n    {},\n    {\n      overwrite: true,\n    },\n  );\n\n  return [...servicesFile];\n}\n\n/**\n * Entity에 딸린 초기 types.ts를 만들어줍니다.\n * @param entityId\n */\nexport async function actionGenerateInitialTypes(entityId: string): Promise<AbsolutePath[]> {\n  return generateTemplate(\"init_types\", { entityId });\n}\n\n/**\n * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSchemas(): Promise<AbsolutePath[]> {\n  return (\n    await Promise.all([\n      generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n      generateTemplate(\"generated\", {}, { overwrite: true }),\n    ])\n  ).flat();\n}\n\n/**\n * sonamu.generated.http를 생성합니다.\n * @returns 생성된 파일 경로.\n */\nexport async function actionGenerateHttps(): Promise<AbsolutePath> {\n  const [res] = await generateTemplate(\n    \"generated_http\",\n    { entityId: \"dummy\" },\n    { overwrite: true },\n  );\n  assert(res);\n  return res;\n}\n\n/**\n * 최종 REST caster를 담는 API 전용 validator registry를 재생성합니다.\n */\nexport async function actionGenerateHttpValidators(): Promise<AbsolutePath> {\n  const registryPath =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ path.join(\n      Sonamu.apiRootPath,\n      \"src/application/sonamu.validators.generated.ts\",\n    ) as AbsolutePath;\n  const policy = Sonamu.config.validation?.zodCompiler;\n  const isAot = isObjectValue(policy) && policy !== null && policy.api === \"aot\";\n  if (!isAot) {\n    // opt-out/JIT 전환 뒤 AOT compile import가 애플리케이션에 남지 않도록 산출물도 함께 정리합니다.\n    if (await syncerFileExists(registryPath)) {\n      await syncerFilesystem.unlink(registryPath);\n    }\n    return registryPath;\n  }\n\n  const [generatedPath] = await generateTemplate(\"http_validators\", {}, { overwrite: true });\n  assert(generatedPath);\n  return generatedPath;\n}\n\n/**\n * queries.generated.ts 재생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSsrQueries(): Promise<AbsolutePath[]> {\n  return generateTemplate(\"queries\", {}, { overwrite: true });\n}\n\n/**\n * entry-server.generated.tsx를 생성합니다.\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n * 입력 의존 없는 정적 코드라 매번 overwrite는 mtime만 갱신하는 의미 없는 동작.\n * 템플릿 자체가 변경된 경우(Sonamu 업그레이드)에는 사용자가 파일을 삭제한 뒤 sync로 재생성.\n * @returns 생성된 파일 경로 배열 (이미 있으면 빈 배열).\n */\nexport async function actionGenerateSsrEntryServerIfNotExists(): Promise<AbsolutePath[]> {\n  try {\n    return await generateTemplate(\"entry_server\", {}, { overwrite: false });\n  } catch (e) {\n    // generateTemplate은 overwrite: false에서 파일이 이미 있으면 예외를 던집니다.\n    // IfNotExists 의미상 \"그냥 놔둔다\"가 정상이므로 빈 배열로 변환합니다.\n    if (e instanceof AlreadyProcessedException) {\n      return [];\n    }\n    throw e;\n  }\n}\n\n/**\n * 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.\n * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,\n * 경로의 /application/은 /services/로 치환됩니다.\n *\n * @param tsPaths 복사할 파일들의 절대 경로\n * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).\n */\nexport async function actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]> {\n  const { targets } = Sonamu.config.sync;\n  const { dir: apiDir } = Sonamu.config.api;\n\n  return (\n    await Promise.all(\n      targets.map(async (target) =>\n        Promise.all(\n          tsPaths.map(async (realSrc) => {\n            const dst = realSrc\n              .replace(`/${apiDir}/`, `/${target}/`)\n              .replace(\"/application/\", \"/services/\");\n            const dir = dirname(dst);\n            if (!(await syncerFileExists(dir))) {\n              await syncerFilesystem.mkdir(dir, { recursive: true });\n            }\n            const syncHeader = [\n              \"/**\",\n              \" * @generated\",\n              \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n              \" */\",\n            ].join(\"\\n\");\n            await copyFileWithReplaceCoreToShared(realSrc, dst, syncHeader);\n            await trackWritten(\n              /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ dst as AbsolutePath,\n            );\n            !isTest() &&\n              console.log(\n                chalk.bold(\"Copied: \") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, \"\")),\n              );\n            return dst;\n          }),\n        ),\n      ),\n    )\n  ).flat();\n}\n\n/**\n * shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.\n * 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.\n *\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n */\nexport async function actionCopySharedToTargetsIfNotExists(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n\n  // plural.ts 내용을 읽어서 shared 파일에 삽입합니다.\n  const dictUtilsPath = path.join(\n    import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n    \"../dict/utils.ts\",\n  );\n  const dictUtilsCode = (await syncerFileExists(dictUtilsPath))\n    ? await syncerFilesystem.readFile(dictUtilsPath, \"utf-8\")\n    : \"\";\n\n  // 특정 변수 치환을 위해서 사용합니다.\n  const convertMap = {\n    baseUrl:\n      Sonamu.config.server.baseUrl ??\n      `http://${Sonamu.config.server.listen?.host ?? \"localhost\"}:${Sonamu.config.server.listen?.port ?? 3000}`,\n    dictUtils: dictUtilsCode,\n  };\n\n  for (const target of targets) {\n    // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.\n    // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.\n    // 따라서 /src/에서 찾습니다.\n    const srcPath = path.join(\n      import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n      `../shared/${target}.shared.ts.txt`,\n    );\n    if (!(await syncerFileExists(srcPath))) {\n      continue;\n    }\n    if (!(await syncerFileExists(path.join(Sonamu.appRootPath, target)))) {\n      throw new Error(\n        `Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`,\n      );\n    }\n\n    const fullText = await syncerFilesystem.readFile(srcPath, \"utf-8\");\n    const convertedText = Object.entries(convertMap).reduce(\n      (acc, [key, value]) => acc.replace(`$[[${key}]]`, value),\n      fullText,\n    );\n\n    // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.\n    const destPath = path.join(Sonamu.appRootPath, target, \"src/services/sonamu.shared.ts\");\n\n    // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.\n    if (!(await syncerFileExists(path.dirname(destPath)))) {\n      await syncerFilesystem.mkdir(path.dirname(destPath), { recursive: true });\n      console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);\n    }\n\n    // 파일이 이미 존재하면 건너뜁니다.\n    // sonamu.shared.ts는 프로젝트에서 자유롭게 커스터마이징할 수 있어야 하므로,\n    // 최초 1회만 생성하고 이후에는 덮어쓰지 않습니다.\n    // 템플릿 내용($[[dictUtils]] 등)이 변경되었을 때 반영이 필요하면,\n    // 해당 파일을 삭제한 뒤 `pnpm sonamu sync`로 재생성하면 됩니다.\n    if (await syncerFileExists(destPath)) {\n      continue;\n    }\n\n    await syncerFilesystem.writeFile(destPath, await formatCode(convertedText, destPath));\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));\n  }\n}\n\n/**\n * Sonamu Dictionary(SD)를 모든 타겟(api + web/app 등)에 동기화합니다.\n *\n * 각 타겟에 대해:\n * - target이 api가 아니면 사용자 작성 locale 파일(ko.ts/en.ts/...)을 api → target으로 복사\n * - sd 템플릿을 렌더링해서 sd.generated.ts 생성 (overwrite)\n *\n * 한 타겟에서 실패해도 다른 타겟은 계속 진행합니다.\n */\nexport async function actionSyncSonamuDictionary(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n  const i18nConfig = Sonamu.config.i18n;\n\n  const targetList =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ [\n      \"api\",\n      ...targets,\n    ] as (\"api\" | \"web\" | \"app\")[];\n\n  const apiI18nDir = path.join(Sonamu.appRootPath, Sonamu.config.api.dir, \"src/i18n\");\n\n  for (const target of targetList) {\n    try {\n      // web/app의 경우 locale 파일들을 api에서 복사\n      if (target !== \"api\") {\n        await syncLocaleFiles(target, apiI18nDir, i18nConfig.supportedLocales);\n      }\n\n      await generateTemplate(\"sd\", { target }, { overwrite: true });\n    } catch (e) {\n      console.error(`Failed to generate SD template for ${target}:`, e);\n    }\n  }\n}\n\n/**\n * api의 locale 파일을 web/app으로 복사합니다.\n */\nasync function syncLocaleFiles(\n  target: string,\n  apiI18nDir: string,\n  locales: string[],\n): Promise<void> {\n  const targetI18nDir = path.join(Sonamu.appRootPath, target, \"src/i18n\");\n\n  // 디렉토리가 없으면 생성\n  await syncerFilesystem.mkdir(targetI18nDir, { recursive: true });\n\n  for (const locale of locales) {\n    const sourceFile = path.join(apiI18nDir, `${locale}.ts`);\n    const targetFile = path.join(targetI18nDir, `${locale}.ts`);\n\n    const syncHeader = [\n      \"/**\",\n      \" * @generated\",\n      \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n      \" */\",\n    ].join(\"\\n\");\n    await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);\n    await trackWritten(\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ targetFile as AbsolutePath,\n    );\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));\n  }\n}\n"],"mappings":"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"}

package/dist/syncer/syncer.js

@@ -24,7 +24,7 @@ import chalk from "chalk";
 import { minimatch } from "minimatch";
 import { EventEmitter } from "events";
 import { hot } from "@sonamu-kit/hmr-hook";
-//#region src/syncer/syncer.ts
+// src/syncer/syncer.ts
 var Syncer;
 var init_syncer = __esmMin((() => {
 	init_decorators();
@@ -268,9 +268,13 @@ var init_syncer = __esmMin((() => {
 				const entityId = EntityManager.getEntityIdFromPath(entityPath);
 				const entity = EntityManager.get(entityId);
 				const typeFilePath = path.join(Sonamu.apiRootPath, `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`);
-				if (entity.parentId === void 0 && !await syncerFileExists(typeFilePath)) await actionSyncFilesToTargets(await actionGenerateInitialTypes(entityId));
+				if (entity.parentId === void 0 && !await syncerFileExists(typeFilePath)) {
+					const types = await actionGenerateInitialTypes(entityId);
+					await actionSyncFilesToTargets(types);
+				}
 			}
-			await actionSyncFilesToTargets((await actionGenerateSchemas()).filter((p) => !p.endsWith(".sso.ts")));
+			const distributable = (await actionGenerateSchemas()).filter((p) => !p.endsWith(".sso.ts"));
+			await actionSyncFilesToTargets(distributable);
 		}
 		async handleImplementationChanges(diffGroups) {
 			Naite.t("handleImplementationChanges", { diffGroups });
@@ -278,20 +282,22 @@ var init_syncer = __esmMin((() => {
 			await this.autoloadModels();
 			await this.autoloadTypes();
 			await this.autoloadApis();
-			await actionGenerateServices(mergedGroup.map((modelPath) => {
+			const params = mergedGroup.map((modelPath) => {
 				if (modelPath.endsWith(".model.ts") || modelPath.endsWith(".frame.ts")) {
 					const entityId = EntityManager.getEntityIdFromPath(modelPath);
 					assert(entityId);
 					return { namesRecord: EntityManager.getNamesFromId(entityId) };
 				}
 				throw new Error("not reachable");
-			}));
+			});
+			await actionGenerateServices(params);
 			await actionGenerateHttps();
 			await actionGenerateSsrQueries();
 		}
 		async handleAuxiliarySymbolChanges(diffGroups) {
 			Naite.t("handleAuxiliarySymbolChanges", { diffGroups });
-			await actionSyncFilesToTargets(unique([...diffGroups.types ?? [], ...diffGroups.functions ?? []]));
+			const tsPaths = unique([...diffGroups.types ?? [], ...diffGroups.functions ?? []]);
+			await actionSyncFilesToTargets(tsPaths);
 		}
 		async handleConfigChanges() {
 			if (process.env.HOT === "yes") {
@@ -392,8 +398,7 @@ var init_syncer = __esmMin((() => {
 		}
 	};
 }));
-//#endregion
 init_syncer();
 export { Syncer, init_syncer };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer.js","names":["SyncerActions.actionCopySharedToTargetsIfNotExists","SyncerActions.actionGenerateSsrEntryServerIfNotExists","SyncerActions.actionGenerateHttpValidators","SyncerActions.actionGenerateInitialTypes","SyncerActions.actionSyncFilesToTargets","SyncerActions.actionGenerateSchemas","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsrQueries","SyncerActions.actionSyncConfig","SyncerActions.actionSyncSonamuDictionary"],"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import assert from \"assert\";\nimport { EventEmitter } from \"events\";\nimport path from \"path\";\n\nimport { hot } from \"@sonamu-kit/hmr-hook\";\nimport chalk from \"chalk\";\nimport { minimatch } from \"minimatch\";\nimport { unique } from \"radashi\";\nimport { type z } from \"zod\";\n\nimport { registeredApis } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { type GenerateOptions, type PathAndCode } from \"../types/types\";\nimport { TemplateKey } from \"../types/types\";\nimport { type TemplateOptions } from \"../types/types\";\nimport { mapAsync, reduceAsync } from \"../utils/async-utils\";\nimport { centerText } from \"../utils/console-util\";\nimport { isTest } from \"../utils/controller\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\nimport { isObjectValue } from \"../utils/runtime-value\";\nimport { findChangedFilesUsingChecksums, renewChecksums } from \"./checksum\";\nimport { generateTemplate, renderTemplate } from \"./code-generator\";\nimport { createEntity, delEntity } from \"./entity-operations\";\nimport { getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { type FileType } from \"./file-patterns\";\nimport { syncerFileExists, syncerFilesystem } from \"./filesystem-dependencies\";\nimport { loadApis, loadModels, loadTypes, loadWorkflows } from \"./module-loader\";\nimport { type LoadedApis, type LoadedModels, type LoadedTypes } from \"./module-loader\";\nimport * as SyncerActions from \"./syncer-actions\";\n\ntype DiffGroupKey = FileType | \"unknown\";\ntype DiffGroups = Partial<Record<DiffGroupKey, AbsolutePath[]>>;\n\nexport class Syncer {\n  apis: LoadedApis = [];\n  types: LoadedTypes = {};\n  models: LoadedModels = {};\n  workflows: Map<string, WorkflowMetadata[]> = new Map();\n  eventEmitter: EventEmitter = new EventEmitter();\n\n  /**\n   * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.\n   * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.\n    // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.\n    // 그래서 아무 때나 그냥 돌려주면 되는데, hmrAndSync에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.\n    await SyncerActions.actionCopySharedToTargetsIfNotExists();\n    await SyncerActions.actionGenerateSsrEntryServerIfNotExists();\n\n    // 바뀐 것이 없으면 그냥 넘어가요.\n    const changedFiles = await findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\n      if (await this.reconcileHttpValidatorRegistry()) {\n        await renewChecksums();\n      }\n      console.log(chalk.black.bgGreen(centerText(\"All files are synced!\")));\n      return;\n    }\n\n    // 여기서 실제 싱크 동작을 수행합니다.\n    // 다만 싱크 중에 프로세스가 죽으면 꼬여버리기 때문에,\n    // 시그널에도 잠시 버틸 수 있는 환경 속에서 싱크를 실행합니다.\n    await runWithGracefulShutdown(\n      async () => {\n        // 얘가 싱크 작업 수행하는 본체입니다.\n        await this.doSyncActions(changedFiles);\n        await this.reconcileHttpValidatorRegistry();\n\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 },\n    );\n  }\n\n  private async reconcileHttpValidatorRegistry(): Promise<boolean> {\n    const registryPath = path.join(\n      Sonamu.apiRootPath,\n      \"src/application/sonamu.validators.generated.ts\",\n    );\n    const policy = Sonamu.config.validation?.zodCompiler;\n    const isAot = isObjectValue(policy) && policy !== null && policy.api === \"aot\";\n    if (isAot === (await syncerFileExists(registryPath))) {\n      return false;\n    }\n\n    // 변경 목록이 registry 삭제를 놓쳐도 checksum 갱신 전에 정책과 산출물을 다시 맞춥니다.\n    await SyncerActions.actionGenerateHttpValidators();\n    return true;\n  }\n\n  /**\n   * 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.\n   *\n   * **사용처**: git post-merge hook, CI, dev 서버의 `f` 핫키.\n   * **실패 안전성**: 도중에 프로세스가 죽어 lock 없는 상태로 남아도 무해 — 다음 sync에서\n   * lock 없으면 자연스럽게 풀-싱크가 트리거되어 새 lock이 작성됨.\n   */\n  async forceSync(): Promise<void> {\n    const lockPath = path.join(Sonamu.apiRootPath, \"sonamu.lock\");\n    if (await syncerFileExists(lockPath)) {\n      await syncerFilesystem.unlink(lockPath);\n    }\n    await this.sync();\n  }\n\n  /**\n   * Watcher가 batch로 모은 변경 파일들에 대해 한 번의 HMR/sync 사이클을 돕니다.\n   *\n   * HMR은 api/src 안에서 일어나는 모든 파일들에 대해서 수행합니다.\n   * checksumPatternGroup 매칭 여부와 무관하게 api/src 전체 대상입니다.\n   * 가령 api/src/utils/subset-loaders.ts 같은 파일도 변경되면 HMR은 해줍니다.\n   *\n   * Sync는 checksumPatternGroup으로 매칭되는 파일들에 대해서만 수행합니다.\n   * 여기에는 web/src나 app/src 같은 다른 target의 파일이 포함될 수 있습니다.\n   * 이런 non-api 경로의 파일들은 HMR과는 아무 상관이 없으므로, invalidate을 하지 않습니다.\n   *\n   * @param fileEvents - path → event 맵. event는 \"change\" | \"add\".\n   */\n  async hmrAndSync(fileEvents: Map<AbsolutePath, \"change\" | \"add\">): Promise<void> {\n    const hmrActionRequiredEvents = this.extractHmrActionRequiredFileEvents(fileEvents);\n    const syncTriggeringPaths = await this.extractSyncTriggeringFileEventPaths(fileEvents);\n\n    // HMR 영역: 파일 이벤트 중 api의 모듈 그래프에 있는 파일들에 대한 변동은 hmrActionRequiredEvents로 잡힙니다.\n    // 이 친구들은 invalidate 처리해줍니다.\n    // 이 호출은 아래 sync보다 무조건 먼저 일어나야 합니다!\n    // 왜냐하면 sync에서는 변경된 model 코드를 새로 import해서 처리해야 하는 경우도 있기 때문입니다.\n    await this.invalidateDependentsAffectedByFileEvents(hmrActionRequiredEvents);\n\n    // Sync 영역: checksumPatternGroup에 명시된 파일들에 대한 변동은 syncTriggeringPaths로 잡힙니다.\n    // 이 친구들은 적절한 sync 작업으로 대응합니다.\n    if (syncTriggeringPaths.length > 0) {\n      await this.doSyncActions(syncTriggeringPaths);\n    }\n\n    // 싱크 작업이 끝났으면 무지성 로드를 수행합니다.\n    // 싱크를 안 한 경우에도 로드는 해야 해요. 위에서 관련있는 친구들은 다 invalidate 되었거든요!\n    //\n    // 변경된 파일들에 대해서 새롭게 당겨오는(load) 행위는 doSyncActions에서 하지 않습니다.\n    // doSyncActions에서는 파일을 읽고 만드는 싱크 행위만 합니다.\n    // 거기서 딱 변경된 부분에 영향받는 autoload만 선별해서 수행하려면 너무 지저분하고 복잡해집니다.\n    //\n    // 퍼포먼스 영향은 무시해도 좋습니다.\n    // 어차피 hmr-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n    await this.autoloadWorkflows();\n    await this.autoloadSsrRoutes();\n    await Sonamu.refreshHttpValidators();\n\n    this.eventEmitter.emit(\"onHMRCompleted\");\n  }\n\n  private extractHmrActionRequiredFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Map<AbsolutePath, \"change\" | \"add\"> {\n    const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n    const result = new Map<AbsolutePath, \"change\" | \"add\">();\n    for (const [filePath, event] of fileEvents) {\n      if (!filePath.startsWith(apiSrc)) {\n        continue;\n      }\n      result.set(filePath, event);\n    }\n    return result;\n  }\n\n  private async extractSyncTriggeringFileEventPaths(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Promise<AbsolutePath[]> {\n    const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n    const syncTriggeringPaths: AbsolutePath[] = [];\n    for (const [diffFilePath] of fileEvents) {\n      const isInCheckPatternGroup = Object.values(checkPatternGroup).some((pattern) =>\n        minimatch(diffFilePath, pattern),\n      );\n      if (!isInCheckPatternGroup) {\n        continue;\n      }\n      syncTriggeringPaths.push(diffFilePath);\n    }\n\n    return syncTriggeringPaths;\n  }\n\n  private async invalidateDependentsAffectedByFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ) {\n    for (const [diffFilePath, event] of fileEvents) {\n      // 변경된 파일과 dependent 파일들을 invalidate 합니다.\n      // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.\n      // 그러니 안심하고 invalidate 해도 됩니다.\n      // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.\n      if (!isTest()) {\n        const invalidatedPaths =\n          /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (await hot.invalidateFile(\n            diffFilePath,\n            event,\n          )) as AbsolutePath[];\n\n        if (invalidatedPaths.length > 0) {\n          console.log(chalk.bold(`🔄 Invalidated:`));\n\n          for (const invalidatedPath of invalidatedPaths) {\n            try {\n              // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.\n              // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.\n              // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.\n              const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);\n              if (removedApis.length > 0) {\n                console.log(\n                  chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),\n                  chalk.gray(`(with ${removedApis.length} APIs)`),\n                );\n              } else {\n                console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));\n              }\n            } catch (e) {\n              console.error(e);\n              console.error(\n                chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`),\n              );\n            }\n          }\n        }\n      }\n\n      // devRunner 활성화 시, 변경된 소스 파일을 Vitest 모듈 그래프에서도 무효화합니다.\n      // Vite의 moduleGraph.invalidateModule()이 importer 방향으로 재귀적 cascade하므로,\n      // 소스 파일 하나만 무효화하면 이를 import하는 테스트 파일도 자동으로 무효화됩니다.\n      if (!isTest() && Sonamu.config.test?.devRunner?.enabled && Sonamu.devVitestManager) {\n        Sonamu.devVitestManager.invalidateFiles([diffFilePath]);\n        console.log(\n          chalk.dim(`Test invalidated: ${path.relative(Sonamu.apiRootPath, diffFilePath)}`),\n        );\n      }\n    }\n  }\n\n  removeInvalidatedRegisteredApis(\n    invalidatedPath: AbsolutePath,\n  ): (typeof registeredApis)[number][] {\n    // 소스 코드를 다루는 상황이니 .ts 경로로 봅니다.\n    const isModel = invalidatedPath.endsWith(\".model.ts\");\n    const isFrame = invalidatedPath.endsWith(\".frame.ts\");\n    if (!isModel && !isFrame) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const targetModelName = `${entityId}${isModel ? \"Model\" : \"Frame\"}`;\n    const toRemove = registeredApis.filter((api) => api.modelName === targetModelName);\n    for (const api of toRemove) {\n      const idx = registeredApis.indexOf(api);\n      if (idx !== -1) {\n        registeredApis.splice(idx, 1);\n      }\n    }\n\n    return toRemove;\n  }\n\n  async autoloadTypes() {\n    this.types = await loadTypes();\n  }\n\n  async autoloadModels() {\n    this.models = await loadModels();\n  }\n\n  async autoloadApis() {\n    this.apis = await loadApis();\n  }\n\n  async autoloadWorkflows() {\n    this.workflows = await loadWorkflows();\n    await Sonamu.workflows.synchronize(this.workflows);\n  }\n\n  async autoloadSsrRoutes(): Promise<void> {\n    const ssrConfigPath = path.join(Sonamu.apiRootPath, \"src/ssr\");\n\n    // 기존 routes 초기화\n    const { clearSSRRoutes } = await import(\"../ssr\");\n    clearSSRRoutes();\n\n    // ssr 폴더 없으면 스킵\n    if (!(await syncerFileExists(ssrConfigPath))) {\n      return;\n    }\n\n    // ssr 폴더 안의 모든 .ts 파일 로드\n    const { globAsync } = await import(\"../utils/async-utils\");\n    const { importMembers } = await import(\"../utils/esm-utils\");\n    const { runtimePath } = await import(\"../utils/path-utils\");\n\n    // runtimePath를 사용하여 개발/프로덕션 환경에 맞는 확장자 처리\n    const files = await globAsync(path.join(ssrConfigPath, runtimePath(\"**/*.ts\")));\n\n    for (const file of files) {\n      try {\n        // importMembers를 사용하면 파일의 side effect(registerSSR 호출)가 실행됨\n        await importMembers(file);\n      } catch (e) {\n        console.error(`Failed to load SSR route: ${file}`, e);\n      }\n    }\n  }\n\n  /**\n   * 실제 싱크를 수행하는 본체입니다.\n   * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.\n   *\n   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록\n   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)\n   */\n  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: FileType[] }> {\n    const diffGroups = this.calculateDiffGroups(diffFilePaths);\n    const diffTypes =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(\n        diffGroups,\n      ) as FileType[];\n\n    // 여기는 별로 중요한 파트는 아닙니다.\n    // 아래의 if 전개를 깔끔하게 하려고 만든 DSL 같은 거라서, 무시하셔도 됩니다.\n    const { changeMatches, unhandledPaths, unhandledChangesLeft } = this.changeMatcher(\n      diffTypes,\n      diffGroups,\n    );\n\n    if (changeMatches(\"entity\", \"types\")) {\n      await this.handleTruthSourceChanges(diffGroups);\n    }\n\n    if (changeMatches(\"model\", \"frame\")) {\n      await this.handleImplementationChanges(diffGroups);\n    }\n\n    if (changeMatches(\"types\", \"functions\")) {\n      await this.handleAuxiliarySymbolChanges(diffGroups);\n    }\n\n    if (changeMatches(\"config\")) {\n      await this.handleConfigChanges();\n    }\n\n    if (changeMatches(\"workflow\")) {\n      // 뭐 딱히 안 해요. 그래도 이 if 조건은 eval되어야 하기 때문에 남겨둡니다 ㅎㅎ\n    }\n\n    if (changeMatches(\"i18n\", \"entity\" /*레이블*/, \"config\" /*defaultLocale등*/)) {\n      await this.handleSonamuDictionaryRelatedChanges();\n    }\n\n    if (changeMatches(\"entity\", \"types\", \"model\", \"frame\", \"config\", \"httpValidatorsGenerated\")) {\n      // 생성물(httpValidatorsGenerated)에 드리프트가 생긴 경우도 처리합니다.\n      // 다른 것 안 바뀌고 딱 httpValidatorsGenerated만 바뀐 경우에도 동등한 처리(=무지성 오토로드)를 합니다. 그냥 이뻐서요 ㅋ\n      await this.handleHttpValidatorRelatedChanges();\n    }\n\n    // 위에서 처리 안 된 변경들이 있다?\n    // 체크섬 관리 대상이긴 한데 위에서 핸들링이 안 된 것이라면 결국 생성물입니다.\n    // 이 친구들이 변경된 것은 drift로 간주해도 마땅합니다.\n    if (unhandledChangesLeft()) {\n      await this.handleDrifts(unhandledPaths());\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  calculateDiffGroups(diffFiles: AbsolutePath[]) {\n    const patternGroup = getChecksumPatternGroup();\n    const fileTypes =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(\n        patternGroup,\n      ) as FileType[];\n\n    const diffGroups: DiffGroups = {};\n    for (const filePath of diffFiles) {\n      // 절대 경로를 appRoot 기준 상대 경로로 바꿔 체크섬 패턴과 비교한다.\n      const relativePath = path.relative(Sonamu.appRootPath, filePath);\n      const fileType = fileTypes.find((candidate) =>\n        minimatch(relativePath, patternGroup[candidate]),\n      );\n      const groupKey: DiffGroupKey = relativePath.startsWith(\"..\")\n        ? \"unknown\"\n        : (fileType ?? \"unknown\");\n      (diffGroups[groupKey] ??= []).push(filePath);\n    }\n    return diffGroups;\n  }\n\n  private changeMatcher(diffTypes: FileType[], diffGroups: DiffGroups) {\n    const handled = new Set<FileType>();\n\n    /**\n     * 변경 사항이 인자로 받은 FileType들 중 하나 이상을 포함하는지 확인합니다.\n     * 가령 [\"entity\"]가 변경된 호출에서 changeMatches(\"entity\")는 trye를 반환하며,\n     * [\"types\", \"i18n\"]이 변경된 호출에서 changeMatches(\"types\", \"functions\")도 true를 반환하지만,\n     * [\"functions\"]가 변경된 호출에서 changeMatches(\"frame\")은 false를 반환합니다.\n     * @param types\n     */\n    const changeMatches = (...types: FileType[]) => {\n      const matching = types.filter((t) => diffTypes.includes(t));\n      matching.forEach((t) => handled.add(t));\n      return matching.length > 0;\n    };\n\n    /**\n     * 어떤 changeMatches 호출에도 걸리지 않은 FileType들의 실제 파일 경로를 모아서 반환합니다.\n     */\n    const unhandledPaths = (): AbsolutePath[] =>\n      diffTypes.filter((t) => !handled.has(t)).flatMap((t) => diffGroups[t] ?? []);\n\n    /**\n     * changeMatches 호출에도 걸리지 않은 FileType들이 존재하는지 확인합니다.\n     */\n    const unhandledChangesLeft = () => unhandledPaths().length > 0;\n\n    return { changeMatches, unhandledPaths, unhandledChangesLeft };\n  }\n\n  async handleTruthSourceChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleTruthSourceChanges\", { diffGroups });\n\n    await EntityManager.reload();\n\n    // types 생성(entity 새로 추가된 경우)\n    // parentId가 없고, types가 없는 경우에만 생성\n    const entityPath = diffGroups.entity?.at(0);\n    if (entityPath !== undefined) {\n      const entityId = EntityManager.getEntityIdFromPath(entityPath);\n      const entity = EntityManager.get(entityId);\n\n      // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.\n      const typeFilePath =\n        /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ path.join(\n          Sonamu.apiRootPath,\n          `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,\n        ) as AbsolutePath;\n\n      if (entity.parentId === undefined && !(await syncerFileExists(typeFilePath))) {\n        // *.types.ts가 만들어집니다.\n        const types = await SyncerActions.actionGenerateInitialTypes(entityId);\n\n        // 그걸 타겟에 갖다둬요.\n        await SyncerActions.actionSyncFilesToTargets(types);\n      }\n    }\n\n    // sonamu.generated.ts와 sonamu.generated.sso.ts가 만들어집니다.\n    const generated = await SyncerActions.actionGenerateSchemas();\n\n    // 모든 것들을 target에 보내지는 않습니다.\n    // sonamu.generated.sso.ts는 service-side-only니까 배제합니다.\n    // TODO(병준): 이 하드코드를 누가 해결 좀 해주세요. 일단은 감당 가능하니 놔두겠습니다...\n    const distributable = generated.filter((p) => !p.endsWith(\".sso.ts\"));\n\n    // 이제 보낼 것들만 target에 보내요.\n    await SyncerActions.actionSyncFilesToTargets(distributable);\n  }\n\n  async handleImplementationChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleImplementationChanges\", { diffGroups });\n    const mergedGroup = [...(diffGroups.model ?? []), ...(diffGroups.frame ?? [])];\n\n    // generated_http.template.ts에서 syncer.types를 씁니다.\n    // service.template.ts에서 syncer.apis를 씁니다.\n    await this.autoloadModels();\n    await this.autoloadTypes();\n    await this.autoloadApis();\n\n    const params: {\n      namesRecord: EntityNamesRecord;\n    }[] = mergedGroup.map((modelPath) => {\n      if (modelPath.endsWith(\".model.ts\") || modelPath.endsWith(\".frame.ts\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      throw new Error(\"not reachable\");\n    });\n\n    await SyncerActions.actionGenerateServices(params);\n    await SyncerActions.actionGenerateHttps();\n    await SyncerActions.actionGenerateSsrQueries();\n  }\n\n  async handleAuxiliarySymbolChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleAuxiliarySymbolChanges\", { diffGroups });\n    const tsPaths = unique([...(diffGroups.types ?? []), ...(diffGroups.functions ?? [])]);\n    await SyncerActions.actionSyncFilesToTargets(tsPaths);\n  }\n\n  async handleConfigChanges(): Promise<void> {\n    if (process.env.HOT === \"yes\") {\n      const { loadConfig } = await import(\"../api/config\");\n      Sonamu.config = await loadConfig(Sonamu.apiRootPath);\n    }\n    await SyncerActions.actionSyncConfig();\n  }\n\n  async handleSonamuDictionaryRelatedChanges(): Promise<void> {\n    await SyncerActions.actionSyncSonamuDictionary();\n  }\n\n  async handleHttpValidatorRelatedChanges(): Promise<void> {\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n    await SyncerActions.actionGenerateHttpValidators();\n  }\n\n  async handleDrifts(drifts: AbsolutePath[]): Promise<void> {\n    if (drifts.length === 0) {\n      return;\n    }\n\n    console.warn(\n      chalk.yellow(\n        \"⚠️ Sonamu가 자동 생성한 파일에 대한 변경이 감지되었습니다. 파일이 Sonamu watcher 외부에서 변경된 것으로 추정됩니다.\",\n      ),\n    );\n    for (const p of drifts) {\n      console.warn(chalk.yellow(`  - ${path.relative(Sonamu.appRootPath, p)}`));\n    }\n    console.warn(chalk.dim(\"  → `pnpm sonamu sync --force`를 권장합니다.\"));\n  }\n\n  /**\n   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param templateKey 템플릿 키\n   * @param enumId 열거형 ID\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExistsGenCode(\n    entityId: string,\n    templateKey: TemplateKey,\n    enumId?: string,\n  ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {\n    const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(\n      EntityManager.getNamesFromId(entityId),\n      enumId,\n    );\n\n    const subPath = path.join(target, genPath);\n    const fullPath = path.join(Sonamu.appRootPath, subPath);\n    return {\n      subPath,\n      fullPath,\n      isExists: await syncerFileExists(fullPath),\n    };\n  }\n\n  /**\n   * 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param enums 열거형 레이블\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExists(\n    entityId: string,\n    enums: {\n      [name: string]: z.ZodEnum;\n    },\n  ): Promise<Record<`${TemplateKey}${string}`, boolean>> {\n    const keys: TemplateKey[] = TemplateKey.options;\n    const names = EntityManager.getNamesFromId(entityId);\n    const enumsKeys = Object.keys(enums).filter((name) => name !== names.constant);\n\n    return await reduceAsync(\n      keys,\n      async (result, key) => {\n        const tpl = TemplateManager.get(key);\n        if (key.startsWith(\"view_enums\")) {\n          await mapAsync(enumsKeys, async (componentId) => {\n            const { target, path: p } = tpl.getTargetAndPath(names, componentId);\n            result[`${key}__${componentId}`] = await syncerFileExists(\n              path.join(Sonamu.appRootPath, target, p),\n            );\n          });\n          return result;\n        }\n\n        const { target, path: p } = tpl.getTargetAndPath(names);\n        const { targets } = Sonamu.config.sync;\n        if (target.includes(\":target\")) {\n          await mapAsync(targets, async (t) => {\n            result[`${key}__${t}`] = await syncerFileExists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p),\n            );\n          });\n        } else {\n          result[key] = await syncerFileExists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ {} as Record<\n        `${TemplateKey}${string}`,\n        boolean\n      >,\n    );\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async createEntity(form: TemplateOptions[\"entity\"]) {\n    return await createEntity(form);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async delEntity(entityId: string): Promise<{ delPaths: string[] }> {\n    return await delEntity(entityId);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async generateTemplate<T extends TemplateKey>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n    _generateOptions?: GenerateOptions,\n  ): Promise<AbsolutePath[]> {\n    return await generateTemplate(key, templateOptions, _generateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renderTemplate<T extends keyof TemplateOptions>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n  ): Promise<PathAndCode[]> {\n    return await renderTemplate(key, templateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renewChecksums(): Promise<void> {\n    return await renewChecksums();\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer.js","names":["SyncerActions.actionCopySharedToTargetsIfNotExists","SyncerActions.actionGenerateSsrEntryServerIfNotExists","SyncerActions.actionGenerateHttpValidators","SyncerActions.actionGenerateInitialTypes","SyncerActions.actionSyncFilesToTargets","SyncerActions.actionGenerateSchemas","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsrQueries","SyncerActions.actionSyncConfig","SyncerActions.actionSyncSonamuDictionary"],"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import assert from \"assert\";\nimport { EventEmitter } from \"events\";\nimport path from \"path\";\n\nimport { hot } from \"@sonamu-kit/hmr-hook\";\nimport chalk from \"chalk\";\nimport { minimatch } from \"minimatch\";\nimport { unique } from \"radashi\";\nimport { type z } from \"zod\";\n\nimport { registeredApis } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { type GenerateOptions, type PathAndCode } from \"../types/types\";\nimport { TemplateKey } from \"../types/types\";\nimport { type TemplateOptions } from \"../types/types\";\nimport { mapAsync, reduceAsync } from \"../utils/async-utils\";\nimport { centerText } from \"../utils/console-util\";\nimport { isTest } from \"../utils/controller\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\nimport { isObjectValue } from \"../utils/runtime-value\";\nimport { findChangedFilesUsingChecksums, renewChecksums } from \"./checksum\";\nimport { generateTemplate, renderTemplate } from \"./code-generator\";\nimport { createEntity, delEntity } from \"./entity-operations\";\nimport { getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { type FileType } from \"./file-patterns\";\nimport { syncerFileExists, syncerFilesystem } from \"./filesystem-dependencies\";\nimport { loadApis, loadModels, loadTypes, loadWorkflows } from \"./module-loader\";\nimport { type LoadedApis, type LoadedModels, type LoadedTypes } from \"./module-loader\";\nimport * as SyncerActions from \"./syncer-actions\";\n\ntype DiffGroupKey = FileType | \"unknown\";\ntype DiffGroups = Partial<Record<DiffGroupKey, AbsolutePath[]>>;\n\nexport class Syncer {\n  apis: LoadedApis = [];\n  types: LoadedTypes = {};\n  models: LoadedModels = {};\n  workflows: Map<string, WorkflowMetadata[]> = new Map();\n  eventEmitter: EventEmitter = new EventEmitter();\n\n  /**\n   * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.\n   * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.\n    // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.\n    // 그래서 아무 때나 그냥 돌려주면 되는데, hmrAndSync에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.\n    await SyncerActions.actionCopySharedToTargetsIfNotExists();\n    await SyncerActions.actionGenerateSsrEntryServerIfNotExists();\n\n    // 바뀐 것이 없으면 그냥 넘어가요.\n    const changedFiles = await findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\n      if (await this.reconcileHttpValidatorRegistry()) {\n        await renewChecksums();\n      }\n      console.log(chalk.black.bgGreen(centerText(\"All files are synced!\")));\n      return;\n    }\n\n    // 여기서 실제 싱크 동작을 수행합니다.\n    // 다만 싱크 중에 프로세스가 죽으면 꼬여버리기 때문에,\n    // 시그널에도 잠시 버틸 수 있는 환경 속에서 싱크를 실행합니다.\n    await runWithGracefulShutdown(\n      async () => {\n        // 얘가 싱크 작업 수행하는 본체입니다.\n        await this.doSyncActions(changedFiles);\n        await this.reconcileHttpValidatorRegistry();\n\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 },\n    );\n  }\n\n  private async reconcileHttpValidatorRegistry(): Promise<boolean> {\n    const registryPath = path.join(\n      Sonamu.apiRootPath,\n      \"src/application/sonamu.validators.generated.ts\",\n    );\n    const policy = Sonamu.config.validation?.zodCompiler;\n    const isAot = isObjectValue(policy) && policy !== null && policy.api === \"aot\";\n    if (isAot === (await syncerFileExists(registryPath))) {\n      return false;\n    }\n\n    // 변경 목록이 registry 삭제를 놓쳐도 checksum 갱신 전에 정책과 산출물을 다시 맞춥니다.\n    await SyncerActions.actionGenerateHttpValidators();\n    return true;\n  }\n\n  /**\n   * 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.\n   *\n   * **사용처**: git post-merge hook, CI, dev 서버의 `f` 핫키.\n   * **실패 안전성**: 도중에 프로세스가 죽어 lock 없는 상태로 남아도 무해 — 다음 sync에서\n   * lock 없으면 자연스럽게 풀-싱크가 트리거되어 새 lock이 작성됨.\n   */\n  async forceSync(): Promise<void> {\n    const lockPath = path.join(Sonamu.apiRootPath, \"sonamu.lock\");\n    if (await syncerFileExists(lockPath)) {\n      await syncerFilesystem.unlink(lockPath);\n    }\n    await this.sync();\n  }\n\n  /**\n   * Watcher가 batch로 모은 변경 파일들에 대해 한 번의 HMR/sync 사이클을 돕니다.\n   *\n   * HMR은 api/src 안에서 일어나는 모든 파일들에 대해서 수행합니다.\n   * checksumPatternGroup 매칭 여부와 무관하게 api/src 전체 대상입니다.\n   * 가령 api/src/utils/subset-loaders.ts 같은 파일도 변경되면 HMR은 해줍니다.\n   *\n   * Sync는 checksumPatternGroup으로 매칭되는 파일들에 대해서만 수행합니다.\n   * 여기에는 web/src나 app/src 같은 다른 target의 파일이 포함될 수 있습니다.\n   * 이런 non-api 경로의 파일들은 HMR과는 아무 상관이 없으므로, invalidate을 하지 않습니다.\n   *\n   * @param fileEvents - path → event 맵. event는 \"change\" | \"add\".\n   */\n  async hmrAndSync(fileEvents: Map<AbsolutePath, \"change\" | \"add\">): Promise<void> {\n    const hmrActionRequiredEvents = this.extractHmrActionRequiredFileEvents(fileEvents);\n    const syncTriggeringPaths = await this.extractSyncTriggeringFileEventPaths(fileEvents);\n\n    // HMR 영역: 파일 이벤트 중 api의 모듈 그래프에 있는 파일들에 대한 변동은 hmrActionRequiredEvents로 잡힙니다.\n    // 이 친구들은 invalidate 처리해줍니다.\n    // 이 호출은 아래 sync보다 무조건 먼저 일어나야 합니다!\n    // 왜냐하면 sync에서는 변경된 model 코드를 새로 import해서 처리해야 하는 경우도 있기 때문입니다.\n    await this.invalidateDependentsAffectedByFileEvents(hmrActionRequiredEvents);\n\n    // Sync 영역: checksumPatternGroup에 명시된 파일들에 대한 변동은 syncTriggeringPaths로 잡힙니다.\n    // 이 친구들은 적절한 sync 작업으로 대응합니다.\n    if (syncTriggeringPaths.length > 0) {\n      await this.doSyncActions(syncTriggeringPaths);\n    }\n\n    // 싱크 작업이 끝났으면 무지성 로드를 수행합니다.\n    // 싱크를 안 한 경우에도 로드는 해야 해요. 위에서 관련있는 친구들은 다 invalidate 되었거든요!\n    //\n    // 변경된 파일들에 대해서 새롭게 당겨오는(load) 행위는 doSyncActions에서 하지 않습니다.\n    // doSyncActions에서는 파일을 읽고 만드는 싱크 행위만 합니다.\n    // 거기서 딱 변경된 부분에 영향받는 autoload만 선별해서 수행하려면 너무 지저분하고 복잡해집니다.\n    //\n    // 퍼포먼스 영향은 무시해도 좋습니다.\n    // 어차피 hmr-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n    await this.autoloadWorkflows();\n    await this.autoloadSsrRoutes();\n    await Sonamu.refreshHttpValidators();\n\n    this.eventEmitter.emit(\"onHMRCompleted\");\n  }\n\n  private extractHmrActionRequiredFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Map<AbsolutePath, \"change\" | \"add\"> {\n    const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n    const result = new Map<AbsolutePath, \"change\" | \"add\">();\n    for (const [filePath, event] of fileEvents) {\n      if (!filePath.startsWith(apiSrc)) {\n        continue;\n      }\n      result.set(filePath, event);\n    }\n    return result;\n  }\n\n  private async extractSyncTriggeringFileEventPaths(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Promise<AbsolutePath[]> {\n    const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n    const syncTriggeringPaths: AbsolutePath[] = [];\n    for (const [diffFilePath] of fileEvents) {\n      const isInCheckPatternGroup = Object.values(checkPatternGroup).some((pattern) =>\n        minimatch(diffFilePath, pattern),\n      );\n      if (!isInCheckPatternGroup) {\n        continue;\n      }\n      syncTriggeringPaths.push(diffFilePath);\n    }\n\n    return syncTriggeringPaths;\n  }\n\n  private async invalidateDependentsAffectedByFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ) {\n    for (const [diffFilePath, event] of fileEvents) {\n      // 변경된 파일과 dependent 파일들을 invalidate 합니다.\n      // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.\n      // 그러니 안심하고 invalidate 해도 됩니다.\n      // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.\n      if (!isTest()) {\n        const invalidatedPaths =\n          /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (await hot.invalidateFile(\n            diffFilePath,\n            event,\n          )) as AbsolutePath[];\n\n        if (invalidatedPaths.length > 0) {\n          console.log(chalk.bold(`🔄 Invalidated:`));\n\n          for (const invalidatedPath of invalidatedPaths) {\n            try {\n              // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.\n              // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.\n              // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.\n              const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);\n              if (removedApis.length > 0) {\n                console.log(\n                  chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),\n                  chalk.gray(`(with ${removedApis.length} APIs)`),\n                );\n              } else {\n                console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));\n              }\n            } catch (e) {\n              console.error(e);\n              console.error(\n                chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`),\n              );\n            }\n          }\n        }\n      }\n\n      // devRunner 활성화 시, 변경된 소스 파일을 Vitest 모듈 그래프에서도 무효화합니다.\n      // Vite의 moduleGraph.invalidateModule()이 importer 방향으로 재귀적 cascade하므로,\n      // 소스 파일 하나만 무효화하면 이를 import하는 테스트 파일도 자동으로 무효화됩니다.\n      if (!isTest() && Sonamu.config.test?.devRunner?.enabled && Sonamu.devVitestManager) {\n        Sonamu.devVitestManager.invalidateFiles([diffFilePath]);\n        console.log(\n          chalk.dim(`Test invalidated: ${path.relative(Sonamu.apiRootPath, diffFilePath)}`),\n        );\n      }\n    }\n  }\n\n  removeInvalidatedRegisteredApis(\n    invalidatedPath: AbsolutePath,\n  ): (typeof registeredApis)[number][] {\n    // 소스 코드를 다루는 상황이니 .ts 경로로 봅니다.\n    const isModel = invalidatedPath.endsWith(\".model.ts\");\n    const isFrame = invalidatedPath.endsWith(\".frame.ts\");\n    if (!isModel && !isFrame) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const targetModelName = `${entityId}${isModel ? \"Model\" : \"Frame\"}`;\n    const toRemove = registeredApis.filter((api) => api.modelName === targetModelName);\n    for (const api of toRemove) {\n      const idx = registeredApis.indexOf(api);\n      if (idx !== -1) {\n        registeredApis.splice(idx, 1);\n      }\n    }\n\n    return toRemove;\n  }\n\n  async autoloadTypes() {\n    this.types = await loadTypes();\n  }\n\n  async autoloadModels() {\n    this.models = await loadModels();\n  }\n\n  async autoloadApis() {\n    this.apis = await loadApis();\n  }\n\n  async autoloadWorkflows() {\n    this.workflows = await loadWorkflows();\n    await Sonamu.workflows.synchronize(this.workflows);\n  }\n\n  async autoloadSsrRoutes(): Promise<void> {\n    const ssrConfigPath = path.join(Sonamu.apiRootPath, \"src/ssr\");\n\n    // 기존 routes 초기화\n    const { clearSSRRoutes } = await import(\"../ssr\");\n    clearSSRRoutes();\n\n    // ssr 폴더 없으면 스킵\n    if (!(await syncerFileExists(ssrConfigPath))) {\n      return;\n    }\n\n    // ssr 폴더 안의 모든 .ts 파일 로드\n    const { globAsync } = await import(\"../utils/async-utils\");\n    const { importMembers } = await import(\"../utils/esm-utils\");\n    const { runtimePath } = await import(\"../utils/path-utils\");\n\n    // runtimePath를 사용하여 개발/프로덕션 환경에 맞는 확장자 처리\n    const files = await globAsync(path.join(ssrConfigPath, runtimePath(\"**/*.ts\")));\n\n    for (const file of files) {\n      try {\n        // importMembers를 사용하면 파일의 side effect(registerSSR 호출)가 실행됨\n        await importMembers(file);\n      } catch (e) {\n        console.error(`Failed to load SSR route: ${file}`, e);\n      }\n    }\n  }\n\n  /**\n   * 실제 싱크를 수행하는 본체입니다.\n   * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.\n   *\n   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록\n   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)\n   */\n  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: FileType[] }> {\n    const diffGroups = this.calculateDiffGroups(diffFilePaths);\n    const diffTypes =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(\n        diffGroups,\n      ) as FileType[];\n\n    // 여기는 별로 중요한 파트는 아닙니다.\n    // 아래의 if 전개를 깔끔하게 하려고 만든 DSL 같은 거라서, 무시하셔도 됩니다.\n    const { changeMatches, unhandledPaths, unhandledChangesLeft } = this.changeMatcher(\n      diffTypes,\n      diffGroups,\n    );\n\n    if (changeMatches(\"entity\", \"types\")) {\n      await this.handleTruthSourceChanges(diffGroups);\n    }\n\n    if (changeMatches(\"model\", \"frame\")) {\n      await this.handleImplementationChanges(diffGroups);\n    }\n\n    if (changeMatches(\"types\", \"functions\")) {\n      await this.handleAuxiliarySymbolChanges(diffGroups);\n    }\n\n    if (changeMatches(\"config\")) {\n      await this.handleConfigChanges();\n    }\n\n    if (changeMatches(\"workflow\")) {\n      // 뭐 딱히 안 해요. 그래도 이 if 조건은 eval되어야 하기 때문에 남겨둡니다 ㅎㅎ\n    }\n\n    if (changeMatches(\"i18n\", \"entity\" /*레이블*/, \"config\" /*defaultLocale등*/)) {\n      await this.handleSonamuDictionaryRelatedChanges();\n    }\n\n    if (changeMatches(\"entity\", \"types\", \"model\", \"frame\", \"config\", \"httpValidatorsGenerated\")) {\n      // 생성물(httpValidatorsGenerated)에 드리프트가 생긴 경우도 처리합니다.\n      // 다른 것 안 바뀌고 딱 httpValidatorsGenerated만 바뀐 경우에도 동등한 처리(=무지성 오토로드)를 합니다. 그냥 이뻐서요 ㅋ\n      await this.handleHttpValidatorRelatedChanges();\n    }\n\n    // 위에서 처리 안 된 변경들이 있다?\n    // 체크섬 관리 대상이긴 한데 위에서 핸들링이 안 된 것이라면 결국 생성물입니다.\n    // 이 친구들이 변경된 것은 drift로 간주해도 마땅합니다.\n    if (unhandledChangesLeft()) {\n      await this.handleDrifts(unhandledPaths());\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  calculateDiffGroups(diffFiles: AbsolutePath[]) {\n    const patternGroup = getChecksumPatternGroup();\n    const fileTypes =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(\n        patternGroup,\n      ) as FileType[];\n\n    const diffGroups: DiffGroups = {};\n    for (const filePath of diffFiles) {\n      // 절대 경로를 appRoot 기준 상대 경로로 바꿔 체크섬 패턴과 비교한다.\n      const relativePath = path.relative(Sonamu.appRootPath, filePath);\n      const fileType = fileTypes.find((candidate) =>\n        minimatch(relativePath, patternGroup[candidate]),\n      );\n      const groupKey: DiffGroupKey = relativePath.startsWith(\"..\")\n        ? \"unknown\"\n        : (fileType ?? \"unknown\");\n      (diffGroups[groupKey] ??= []).push(filePath);\n    }\n    return diffGroups;\n  }\n\n  private changeMatcher(diffTypes: FileType[], diffGroups: DiffGroups) {\n    const handled = new Set<FileType>();\n\n    /**\n     * 변경 사항이 인자로 받은 FileType들 중 하나 이상을 포함하는지 확인합니다.\n     * 가령 [\"entity\"]가 변경된 호출에서 changeMatches(\"entity\")는 trye를 반환하며,\n     * [\"types\", \"i18n\"]이 변경된 호출에서 changeMatches(\"types\", \"functions\")도 true를 반환하지만,\n     * [\"functions\"]가 변경된 호출에서 changeMatches(\"frame\")은 false를 반환합니다.\n     * @param types\n     */\n    const changeMatches = (...types: FileType[]) => {\n      const matching = types.filter((t) => diffTypes.includes(t));\n      matching.forEach((t) => handled.add(t));\n      return matching.length > 0;\n    };\n\n    /**\n     * 어떤 changeMatches 호출에도 걸리지 않은 FileType들의 실제 파일 경로를 모아서 반환합니다.\n     */\n    const unhandledPaths = (): AbsolutePath[] =>\n      diffTypes.filter((t) => !handled.has(t)).flatMap((t) => diffGroups[t] ?? []);\n\n    /**\n     * changeMatches 호출에도 걸리지 않은 FileType들이 존재하는지 확인합니다.\n     */\n    const unhandledChangesLeft = () => unhandledPaths().length > 0;\n\n    return { changeMatches, unhandledPaths, unhandledChangesLeft };\n  }\n\n  async handleTruthSourceChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleTruthSourceChanges\", { diffGroups });\n\n    await EntityManager.reload();\n\n    // types 생성(entity 새로 추가된 경우)\n    // parentId가 없고, types가 없는 경우에만 생성\n    const entityPath = diffGroups.entity?.at(0);\n    if (entityPath !== undefined) {\n      const entityId = EntityManager.getEntityIdFromPath(entityPath);\n      const entity = EntityManager.get(entityId);\n\n      // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.\n      const typeFilePath =\n        /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ path.join(\n          Sonamu.apiRootPath,\n          `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,\n        ) as AbsolutePath;\n\n      if (entity.parentId === undefined && !(await syncerFileExists(typeFilePath))) {\n        // *.types.ts가 만들어집니다.\n        const types = await SyncerActions.actionGenerateInitialTypes(entityId);\n\n        // 그걸 타겟에 갖다둬요.\n        await SyncerActions.actionSyncFilesToTargets(types);\n      }\n    }\n\n    // sonamu.generated.ts와 sonamu.generated.sso.ts가 만들어집니다.\n    const generated = await SyncerActions.actionGenerateSchemas();\n\n    // 모든 것들을 target에 보내지는 않습니다.\n    // sonamu.generated.sso.ts는 service-side-only니까 배제합니다.\n    // TODO(병준): 이 하드코드를 누가 해결 좀 해주세요. 일단은 감당 가능하니 놔두겠습니다...\n    const distributable = generated.filter((p) => !p.endsWith(\".sso.ts\"));\n\n    // 이제 보낼 것들만 target에 보내요.\n    await SyncerActions.actionSyncFilesToTargets(distributable);\n  }\n\n  async handleImplementationChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleImplementationChanges\", { diffGroups });\n    const mergedGroup = [...(diffGroups.model ?? []), ...(diffGroups.frame ?? [])];\n\n    // generated_http.template.ts에서 syncer.types를 씁니다.\n    // service.template.ts에서 syncer.apis를 씁니다.\n    await this.autoloadModels();\n    await this.autoloadTypes();\n    await this.autoloadApis();\n\n    const params: {\n      namesRecord: EntityNamesRecord;\n    }[] = mergedGroup.map((modelPath) => {\n      if (modelPath.endsWith(\".model.ts\") || modelPath.endsWith(\".frame.ts\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      throw new Error(\"not reachable\");\n    });\n\n    await SyncerActions.actionGenerateServices(params);\n    await SyncerActions.actionGenerateHttps();\n    await SyncerActions.actionGenerateSsrQueries();\n  }\n\n  async handleAuxiliarySymbolChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleAuxiliarySymbolChanges\", { diffGroups });\n    const tsPaths = unique([...(diffGroups.types ?? []), ...(diffGroups.functions ?? [])]);\n    await SyncerActions.actionSyncFilesToTargets(tsPaths);\n  }\n\n  async handleConfigChanges(): Promise<void> {\n    if (process.env.HOT === \"yes\") {\n      const { loadConfig } = await import(\"../api/config\");\n      Sonamu.config = await loadConfig(Sonamu.apiRootPath);\n    }\n    await SyncerActions.actionSyncConfig();\n  }\n\n  async handleSonamuDictionaryRelatedChanges(): Promise<void> {\n    await SyncerActions.actionSyncSonamuDictionary();\n  }\n\n  async handleHttpValidatorRelatedChanges(): Promise<void> {\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n    await SyncerActions.actionGenerateHttpValidators();\n  }\n\n  async handleDrifts(drifts: AbsolutePath[]): Promise<void> {\n    if (drifts.length === 0) {\n      return;\n    }\n\n    console.warn(\n      chalk.yellow(\n        \"⚠️ Sonamu가 자동 생성한 파일에 대한 변경이 감지되었습니다. 파일이 Sonamu watcher 외부에서 변경된 것으로 추정됩니다.\",\n      ),\n    );\n    for (const p of drifts) {\n      console.warn(chalk.yellow(`  - ${path.relative(Sonamu.appRootPath, p)}`));\n    }\n    console.warn(chalk.dim(\"  → `pnpm sonamu sync --force`를 권장합니다.\"));\n  }\n\n  /**\n   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param templateKey 템플릿 키\n   * @param enumId 열거형 ID\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExistsGenCode(\n    entityId: string,\n    templateKey: TemplateKey,\n    enumId?: string,\n  ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {\n    const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(\n      EntityManager.getNamesFromId(entityId),\n      enumId,\n    );\n\n    const subPath = path.join(target, genPath);\n    const fullPath = path.join(Sonamu.appRootPath, subPath);\n    return {\n      subPath,\n      fullPath,\n      isExists: await syncerFileExists(fullPath),\n    };\n  }\n\n  /**\n   * 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param enums 열거형 레이블\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExists(\n    entityId: string,\n    enums: {\n      [name: string]: z.ZodEnum;\n    },\n  ): Promise<Record<`${TemplateKey}${string}`, boolean>> {\n    const keys: TemplateKey[] = TemplateKey.options;\n    const names = EntityManager.getNamesFromId(entityId);\n    const enumsKeys = Object.keys(enums).filter((name) => name !== names.constant);\n\n    return await reduceAsync(\n      keys,\n      async (result, key) => {\n        const tpl = TemplateManager.get(key);\n        if (key.startsWith(\"view_enums\")) {\n          await mapAsync(enumsKeys, async (componentId) => {\n            const { target, path: p } = tpl.getTargetAndPath(names, componentId);\n            result[`${key}__${componentId}`] = await syncerFileExists(\n              path.join(Sonamu.appRootPath, target, p),\n            );\n          });\n          return result;\n        }\n\n        const { target, path: p } = tpl.getTargetAndPath(names);\n        const { targets } = Sonamu.config.sync;\n        if (target.includes(\":target\")) {\n          await mapAsync(targets, async (t) => {\n            result[`${key}__${t}`] = await syncerFileExists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p),\n            );\n          });\n        } else {\n          result[key] = await syncerFileExists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ {} as Record<\n        `${TemplateKey}${string}`,\n        boolean\n      >,\n    );\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async createEntity(form: TemplateOptions[\"entity\"]) {\n    return await createEntity(form);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async delEntity(entityId: string): Promise<{ delPaths: string[] }> {\n    return await delEntity(entityId);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async generateTemplate<T extends TemplateKey>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n    _generateOptions?: GenerateOptions,\n  ): Promise<AbsolutePath[]> {\n    return await generateTemplate(key, templateOptions, _generateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renderTemplate<T extends keyof TemplateOptions>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n  ): Promise<PathAndCode[]> {\n    return await renderTemplate(key, templateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renewChecksums(): Promise<void> {\n    return await renewChecksums();\n  }\n}\n"],"mappings":"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"}

package/dist/syncer/watcher.js

@@ -9,7 +9,7 @@ import path from "path";
 import chalk from "chalk";
 import { minimatch } from "minimatch";
 import { watch } from "chokidar";
-//#region src/syncer/watcher.ts
+// src/syncer/watcher.ts
 /**
 * Watcher를 설정합니다.
 * 이 친구는 진짜로 syncer가 받아야 할 변경 이벤트들만 추려서 batch로 전달해줍니다.
@@ -79,7 +79,6 @@ function isOutOfScope(filePath) {
 	const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();
 	return !Object.values(checkPatternGroup).some((pattern) => minimatch(filePath, pattern));
 }
-//#endregion
 __esmMin((() => {
 	init_api();
 	init_event_batcher();
@@ -88,4 +87,4 @@ __esmMin((() => {
 }))();
 export { setupWatcher };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"watcher.js","names":[],"sources":["../../src/syncer/watcher.ts"],"sourcesContent":["import { strict as assert } from \"assert\";\nimport { type Stats } from \"node:fs\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { type FSWatcher, watch } from \"chokidar\";\nimport { minimatch } from \"minimatch\";\n\nimport { Sonamu } from \"../api\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { createFileEventBatcher } from \"./event-batcher\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { isLastChangedByMe } from \"./file-tracking\";\n\n/**\n * Watcher를 설정합니다.\n * 이 친구는 진짜로 syncer가 받아야 할 변경 이벤트들만 추려서 batch로 전달해줍니다.\n */\nexport async function setupWatcher(\n  onFileEvents: (fileEvents: Map<AbsolutePath, \"change\" | \"add\">) => Promise<void>,\n): Promise<FSWatcher> {\n  // api 본인뿐 아니라 sync target들의 src도 봅니다.\n  // target 산출물(sonamu.generated, services.generated, i18n copy 등)이 외부에서\n  // 변경되는 경우를 drift로 잡아 워닝을 띄우기 위함입니다.\n  const watcher = watch(apiAndTargetsSrcPaths(), {\n    ignored: ignoreIfExtensionIsNotOneOf(\".ts\", \".json\", \".http\"),\n    persistent: true,\n    ignoreInitial: true,\n  });\n\n  // 100ms 안에 들어온 변경들을 한 batch로 모아 한 사이클로 처리합니다.\n  const pushFileEvent = createFileEventBatcher<\"change\" | \"add\">({\n    delayMs: 100,\n    onFlush: async (fileEvents) => {\n      const realChanges = new Map<AbsolutePath, \"change\" | \"add\">();\n      for (const [p, e] of fileEvents) {\n        // self-write echo는 flush 시점에 거릅니다.\n        // watcher.on에서 즉시 거르면 너무 이릅니다.\n        // 여기에서는 파일이 디스크에 쓰이고 나서 약간의 딜레이가 있기 때문에\n        // \"디스크에 썼지만 아직 trackWritten이 완료되기 전 상태\" 같은 문제가 사라집니다.\n        if (!(await isLastChangedByMe(p))) {\n          realChanges.set(p, e);\n        }\n      }\n      if (realChanges.size > 0) {\n        await onFileEvents(realChanges);\n      }\n    },\n  });\n\n  watcher.on(\"all\", (event: string, filePath: string) => {\n    const absolutePath =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ filePath as AbsolutePath;\n    assert(\n      absolutePath.startsWith(Sonamu.appRootPath),\n      \"File path is not within the app root path\",\n    );\n\n    if (!isWantedEvent(event)) {\n      return;\n    }\n\n    if (isConfigChange(absolutePath)) {\n      triggerSelfRestart(event, filePath);\n      return;\n    }\n\n    if (isOutOfScope(absolutePath)) {\n      return;\n    }\n\n    // 여기까지 왔다면 syncer가 진짜로 처리해야 할 변경사항이라고 보면 됩니다.\n    // 이 호출은 이벤트를 batcher에 쌓습니다.\n    // 이후 때가 되면 이렇게 쌓인 이벤트를 들고 onFileEvents 콜백이 호출됩니다.\n    pushFileEvent(absolutePath, event);\n  });\n\n  return watcher;\n}\n\nfunction apiAndTargetsSrcPaths() {\n  return [\n    path.join(Sonamu.apiRootPath, \"src\"),\n    ...Sonamu.config.sync.targets.map((t) => path.join(Sonamu.appRootPath, t, \"src\")),\n  ];\n}\n\n/**\n * chokidar의 `ignored` 옵션에 박는 헬퍼.\n * 주어진 확장자가 *아닌* 파일은 무시합니다 — 즉 주어진 확장자만 watch 대상.\n *\n * chokidar `ignored`는 `true`를 반환하면 해당 경로를 무시합니다.\n * 따라서 \"이 확장자만 허용\"을 표현하려면 *다른 확장자에 대해 true*를 반환해야 합니다.\n */\nfunction ignoreIfExtensionIsNotOneOf(...allowedExtensions: `.${string}`[]) {\n  const isAllowed = (ext: string) =>\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (\n      allowedExtensions as string[]\n    ).includes(ext);\n\n  return (p: string, stats?: Stats) => !!stats?.isFile() && !isAllowed(path.extname(p));\n}\n\nfunction isWantedEvent(event: string): event is \"change\" | \"add\" {\n  return event === \"change\" || event === \"add\";\n}\n\nfunction isConfigChange(filePath: AbsolutePath): boolean {\n  return filePath === path.join(Sonamu.apiRootPath, \"src\", \"sonamu.config.ts\");\n}\n\nfunction triggerSelfRestart(event: string, filePath: string): void {\n  const relativePath = filePath.replace(Sonamu.apiRootPath, \"api\");\n  console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`));\n  process.kill(process.pid, \"SIGUSR2\");\n}\n\n/**\n * 스코프 정의:\n * - api/src 안의 모든 변경은 스코프 안 (HMR 대상이 될 수 있으므로)\n * - api/src 밖이라면 checksumPatternGroup 패턴에 매칭되는 경로만 스코프 안\n *\n * 그 외(예: web/src/App.tsx 같은 target의 비추적 파일)는 스코프 밖이라 무시합니다.\n */\nfunction isOutOfScope(filePath: AbsolutePath): boolean {\n  const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n  if (filePath.startsWith(apiSrc)) {\n    return false;\n  }\n  const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n  return !Object.values(checkPatternGroup).some((pattern) => minimatch(filePath, pattern));\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,eAAsB,aACpB,cACoB;CAIpB,MAAM,UAAU,MAAM,sBAAsB,GAAG;EAC7C,SAAS,4BAA4B,OAAO,SAAS,OAAO;EAC5D,YAAY;EACZ,eAAe;CACjB,CAAC;CAGD,MAAM,gBAAgB,uBAAyC;EAC7D,SAAS;EACT,SAAS,OAAO,eAAe;GAC7B,MAAM,8BAAc,IAAI,IAAoC;GAC5D,KAAK,MAAM,CAAC,GAAG,MAAM,YAKnB,IAAI,CAAE,MAAM,kBAAkB,CAAC,GAC7B,YAAY,IAAI,GAAG,CAAC;GAGxB,IAAI,YAAY,OAAO,GACrB,MAAM,aAAa,WAAW;EAElC;CACF,CAAC;CAED,QAAQ,GAAG,QAAQ,OAAe,aAAqB;EACrD,MAAM,eACuD;EAC7D,OACE,aAAa,WAAW,OAAO,WAAW,GAC1C,2CACF;EAEA,IAAI,CAAC,cAAc,KAAK,GACtB;EAGF,IAAI,eAAe,YAAY,GAAG;GAChC,mBAAmB,OAAO,QAAQ;GAClC;EACF;EAEA,IAAI,aAAa,YAAY,GAC3B;EAMF,cAAc,cAAc,KAAK;CACnC,CAAC;CAED,OAAO;AACT;AAEA,SAAS,wBAAwB;CAC/B,OAAO,CACL,KAAK,KAAK,OAAO,aAAa,KAAK,GACnC,GAAG,OAAO,OAAO,KAAK,QAAQ,KAAK,MAAM,KAAK,KAAK,OAAO,aAAa,GAAG,KAAK,CAAC,CAClF;AACF;;;;;;;;AASA,SAAS,4BAA4B,GAAG,mBAAmC;CACzE,MAAM,aAAa,QAEf,kBACA,SAAS,GAAG;CAEhB,QAAQ,GAAW,UAAkB,CAAC,CAAC,OAAO,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC;AACtF;AAEA,SAAS,cAAc,OAA0C;CAC/D,OAAO,UAAU,YAAY,UAAU;AACzC;AAEA,SAAS,eAAe,UAAiC;CACvD,OAAO,aAAa,KAAK,KAAK,OAAO,aAAa,OAAO,kBAAkB;AAC7E;AAEA,SAAS,mBAAmB,OAAe,UAAwB;CACjE,MAAM,eAAe,SAAS,QAAQ,OAAO,aAAa,KAAK;CAC/D,QAAQ,IAAI,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,KAAK,YAAY,EAAE,iBAAiB,CAAC;CACzF,QAAQ,KAAK,QAAQ,KAAK,SAAS;AACrC;;;;;;;;AASA,SAAS,aAAa,UAAiC;CACrD,MAAM,SAAS,KAAK,KAAK,OAAO,aAAa,KAAK;CAClD,IAAI,SAAS,WAAW,MAAM,GAC5B,OAAO;CAET,MAAM,oBAAoB,sCAAsC;CAChE,OAAO,CAAC,OAAO,OAAO,iBAAiB,CAAC,CAAC,MAAM,YAAY,UAAU,UAAU,OAAO,CAAC;AACzF;;;UA3H+B;oBAEyB;oBACe;oBACpB"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"watcher.js","names":[],"sources":["../../src/syncer/watcher.ts"],"sourcesContent":["import { strict as assert } from \"assert\";\nimport { type Stats } from \"node:fs\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { type FSWatcher, watch } from \"chokidar\";\nimport { minimatch } from \"minimatch\";\n\nimport { Sonamu } from \"../api\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { createFileEventBatcher } from \"./event-batcher\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { isLastChangedByMe } from \"./file-tracking\";\n\n/**\n * Watcher를 설정합니다.\n * 이 친구는 진짜로 syncer가 받아야 할 변경 이벤트들만 추려서 batch로 전달해줍니다.\n */\nexport async function setupWatcher(\n  onFileEvents: (fileEvents: Map<AbsolutePath, \"change\" | \"add\">) => Promise<void>,\n): Promise<FSWatcher> {\n  // api 본인뿐 아니라 sync target들의 src도 봅니다.\n  // target 산출물(sonamu.generated, services.generated, i18n copy 등)이 외부에서\n  // 변경되는 경우를 drift로 잡아 워닝을 띄우기 위함입니다.\n  const watcher = watch(apiAndTargetsSrcPaths(), {\n    ignored: ignoreIfExtensionIsNotOneOf(\".ts\", \".json\", \".http\"),\n    persistent: true,\n    ignoreInitial: true,\n  });\n\n  // 100ms 안에 들어온 변경들을 한 batch로 모아 한 사이클로 처리합니다.\n  const pushFileEvent = createFileEventBatcher<\"change\" | \"add\">({\n    delayMs: 100,\n    onFlush: async (fileEvents) => {\n      const realChanges = new Map<AbsolutePath, \"change\" | \"add\">();\n      for (const [p, e] of fileEvents) {\n        // self-write echo는 flush 시점에 거릅니다.\n        // watcher.on에서 즉시 거르면 너무 이릅니다.\n        // 여기에서는 파일이 디스크에 쓰이고 나서 약간의 딜레이가 있기 때문에\n        // \"디스크에 썼지만 아직 trackWritten이 완료되기 전 상태\" 같은 문제가 사라집니다.\n        if (!(await isLastChangedByMe(p))) {\n          realChanges.set(p, e);\n        }\n      }\n      if (realChanges.size > 0) {\n        await onFileEvents(realChanges);\n      }\n    },\n  });\n\n  watcher.on(\"all\", (event: string, filePath: string) => {\n    const absolutePath =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ filePath as AbsolutePath;\n    assert(\n      absolutePath.startsWith(Sonamu.appRootPath),\n      \"File path is not within the app root path\",\n    );\n\n    if (!isWantedEvent(event)) {\n      return;\n    }\n\n    if (isConfigChange(absolutePath)) {\n      triggerSelfRestart(event, filePath);\n      return;\n    }\n\n    if (isOutOfScope(absolutePath)) {\n      return;\n    }\n\n    // 여기까지 왔다면 syncer가 진짜로 처리해야 할 변경사항이라고 보면 됩니다.\n    // 이 호출은 이벤트를 batcher에 쌓습니다.\n    // 이후 때가 되면 이렇게 쌓인 이벤트를 들고 onFileEvents 콜백이 호출됩니다.\n    pushFileEvent(absolutePath, event);\n  });\n\n  return watcher;\n}\n\nfunction apiAndTargetsSrcPaths() {\n  return [\n    path.join(Sonamu.apiRootPath, \"src\"),\n    ...Sonamu.config.sync.targets.map((t) => path.join(Sonamu.appRootPath, t, \"src\")),\n  ];\n}\n\n/**\n * chokidar의 `ignored` 옵션에 박는 헬퍼.\n * 주어진 확장자가 *아닌* 파일은 무시합니다 — 즉 주어진 확장자만 watch 대상.\n *\n * chokidar `ignored`는 `true`를 반환하면 해당 경로를 무시합니다.\n * 따라서 \"이 확장자만 허용\"을 표현하려면 *다른 확장자에 대해 true*를 반환해야 합니다.\n */\nfunction ignoreIfExtensionIsNotOneOf(...allowedExtensions: `.${string}`[]) {\n  const isAllowed = (ext: string) =>\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (\n      allowedExtensions as string[]\n    ).includes(ext);\n\n  return (p: string, stats?: Stats) => !!stats?.isFile() && !isAllowed(path.extname(p));\n}\n\nfunction isWantedEvent(event: string): event is \"change\" | \"add\" {\n  return event === \"change\" || event === \"add\";\n}\n\nfunction isConfigChange(filePath: AbsolutePath): boolean {\n  return filePath === path.join(Sonamu.apiRootPath, \"src\", \"sonamu.config.ts\");\n}\n\nfunction triggerSelfRestart(event: string, filePath: string): void {\n  const relativePath = filePath.replace(Sonamu.apiRootPath, \"api\");\n  console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`));\n  process.kill(process.pid, \"SIGUSR2\");\n}\n\n/**\n * 스코프 정의:\n * - api/src 안의 모든 변경은 스코프 안 (HMR 대상이 될 수 있으므로)\n * - api/src 밖이라면 checksumPatternGroup 패턴에 매칭되는 경로만 스코프 안\n *\n * 그 외(예: web/src/App.tsx 같은 target의 비추적 파일)는 스코프 밖이라 무시합니다.\n */\nfunction isOutOfScope(filePath: AbsolutePath): boolean {\n  const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n  if (filePath.startsWith(apiSrc)) {\n    return false;\n  }\n  const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n  return !Object.values(checkPatternGroup).some((pattern) => minimatch(filePath, pattern));\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,eAAsB,aACpB,cACoB;CAIpB,MAAM,UAAU,MAAM,sBAAsB,GAAG;EAC7C,SAAS,4BAA4B,OAAO,SAAS,OAAO;EAC5D,YAAY;EACZ,eAAe;CACjB,CAAC;CAGD,MAAM,gBAAgB,uBAAyC;EAC7D,SAAS;EACT,SAAS,OAAO,eAAe;GAC7B,MAAM,8BAAc,IAAI,IAAoC;GAC5D,KAAK,MAAM,CAAC,GAAG,MAAM,YAKnB,IAAI,CAAE,MAAM,kBAAkB,CAAC,GAC7B,YAAY,IAAI,GAAG,CAAC;GAGxB,IAAI,YAAY,OAAO,GACrB,MAAM,aAAa,WAAW;EAElC;CACF,CAAC;CAED,QAAQ,GAAG,QAAQ,OAAe,aAAqB;EACrD,MAAM,eACuD;EAC7D,OACE,aAAa,WAAW,OAAO,WAAW,GAC1C,2CACF;EAEA,IAAI,CAAC,cAAc,KAAK,GACtB;EAGF,IAAI,eAAe,YAAY,GAAG;GAChC,mBAAmB,OAAO,QAAQ;GAClC;EACF;EAEA,IAAI,aAAa,YAAY,GAC3B;EAMF,cAAc,cAAc,KAAK;CACnC,CAAC;CAED,OAAO;AACT;AAEA,SAAS,wBAAwB;CAC/B,OAAO,CACL,KAAK,KAAK,OAAO,aAAa,KAAK,GACnC,GAAG,OAAO,OAAO,KAAK,QAAQ,KAAK,MAAM,KAAK,KAAK,OAAO,aAAa,GAAG,KAAK,CAAC,CAClF;AACF;;;;;;;;AASA,SAAS,4BAA4B,GAAG,mBAAmC;CACzE,MAAM,aAAa,QAEf,kBACA,SAAS,GAAG;CAEhB,QAAQ,GAAW,UAAkB,CAAC,CAAC,OAAO,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC;AACtF;AAEA,SAAS,cAAc,OAA0C;CAC/D,OAAO,UAAU,YAAY,UAAU;AACzC;AAEA,SAAS,eAAe,UAAiC;CACvD,OAAO,aAAa,KAAK,KAAK,OAAO,aAAa,OAAO,kBAAkB;AAC7E;AAEA,SAAS,mBAAmB,OAAe,UAAwB;CACjE,MAAM,eAAe,SAAS,QAAQ,OAAO,aAAa,KAAK;CAC/D,QAAQ,IAAI,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,KAAK,YAAY,EAAE,iBAAiB,CAAC;CACzF,QAAQ,KAAK,QAAQ,KAAK,SAAS;AACrC;;;;;;;;AASA,SAAS,aAAa,UAAiC;CACrD,MAAM,SAAS,KAAK,KAAK,OAAO,aAAa,KAAK;CAClD,IAAI,SAAS,WAAW,MAAM,GAC5B,OAAO;CAET,MAAM,oBAAoB,sCAAsC;CAChE,OAAO,CAAC,OAAO,OAAO,iBAAiB,CAAC,CAAC,MAAM,YAAY,UAAU,UAAU,OAAO,CAAC;AACzF;;CA3H+B,SAAA;CAEyB,mBAAA;CACe,mBAAA;CACpB,mBAAA"}