sonamu 0.9.4 → 0.9.6

package/dist/syncer/syncer.js

@@ -1,30 +1,29 @@
 import { __esmMin } from "../_virtual/rolldown_runtime.js";
-import { AlreadyProcessedException, init_so_exceptions } from "../exceptions/so-exceptions.js";
+import { centerText, init_console_util } from "../utils/console-util.js";
 import { init_controller, isTest } from "../utils/controller.js";
-import { copyFileWithReplaceCoreToShared, exists, init_fs_utils } from "../utils/fs-utils.js";
+import { init_async_utils, mapAsync, reduceAsync } from "../utils/async-utils.js";
+import { init_process_utils, runWithGracefulShutdown } from "../utils/process-utils.js";
+import { exists, init_fs_utils } from "../utils/fs-utils.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { TemplateKey, init_types } from "../types/types.js";
-import { init_async_utils, mapAsync, reduceAsync } from "../utils/async-utils.js";
 import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
 import { Naite, init_naite } from "../naite/naite.js";
 import { init_decorators, registeredApis } from "../api/decorators.js";
-import { centerText, init_console_util } from "../utils/console-util.js";
 import { TemplateManager, init_template_manager } from "../template/template-manager.js";
-import { checksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
+import { getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
 import { findChangedFilesUsingChecksums, init_checksum, renewChecksums } from "./checksum.js";
 import { generateTemplate, init_code_generator, renderTemplate } from "./code-generator.js";
 import { createEntity, delEntity, init_entity_operations } from "./entity-operations.js";
 import { init_module_loader, loadApis, loadModels, loadTypes, loadWorkflows } from "./module-loader.js";
-import { init_process_utils, runWithGracefulShutdown } from "../utils/process-utils.js";
-import { actionGenerateHttps, actionGenerateSchemas, actionGenerateServices, actionGenerateSsr, actionSyncConfig, actionSyncFilesToTargets, init_syncer_actions } from "./syncer-actions.js";
+import { actionCopySharedToTargetsIfNotExists, actionGenerateHttps, actionGenerateInitialTypes, actionGenerateSchemas, actionGenerateServices, actionGenerateSsrEntryServerIfNotExists, actionGenerateSsrQueries, actionSyncConfig, actionSyncFilesToTargets, actionSyncSonamuDictionary, init_syncer_actions } from "./syncer-actions.js";
 import { group, unique } from "radashi";
 import assert from "assert";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { unlink } from "fs/promises";
 import path from "path";
 import chalk from "chalk";
+import { minimatch } from "minimatch";
 import { EventEmitter } from "events";
 import { hot } from "@sonamu-kit/hmr-hook";
-import { minimatch } from "minimatch";
 
 //#region src/syncer/syncer.ts
 var Syncer;
@@ -32,7 +31,6 @@ var init_syncer = __esmMin((() => {
 	init_decorators();
 	init_sonamu();
 	init_entity_manager();
-	init_so_exceptions();
 	init_naite();
 	init_template_manager();
 	init_types();
@@ -55,23 +53,15 @@ var init_syncer = __esmMin((() => {
 		eventEmitter = new EventEmitter();
 		/**
 		* 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
-		* sonamu.shared.ts는 파일이 없을 때만 1회 생성하고, 이후에는 덮어쓰지 않습니다.
+		* dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 syncFromWatcher 경로를 타요.
 		* @returns
 		*/
 		async sync() {
-			const { targets } = Sonamu.config.sync;
-			await this.copySharedToTargets(targets);
+			await actionCopySharedToTargetsIfNotExists();
+			await actionGenerateSsrEntryServerIfNotExists();
 			const changedFiles = await findChangedFilesUsingChecksums();
 			if (changedFiles.length === 0) {
 				console.log(chalk.black.bgGreen(centerText("All files are synced!")));
-				try {
-					await generateTemplate("queries", {}, { overwrite: false });
-					await generateTemplate("entry_server", {}, { overwrite: false });
-				} catch (e) {
-					if (!(e instanceof AlreadyProcessedException)) {
-						console.error("Failed to generate SSR templates:", e);
-					}
-				}
 				return;
 			}
 			await runWithGracefulShutdown(async () => {
@@ -83,56 +73,95 @@ var init_syncer = __esmMin((() => {
 			});
 		}
 		/**
-		* Watcher가 감지한 파일 변경 사항에 대해 싱크를 진행합니다.
-		* 주어진 변경 파일들 중 체크섬 관리 대상인 것들만 가져다가 싱크를 진행합니다.
-		* 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.
-		* @param diffFilePath - 변경 파일들. 프로젝트 루트부터 "src/" 또는 "dist/"로 시작하는 상대 경로입니다. 예시: "src/application/user/user.model.ts"
+		* 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.
+		*
+		* **사용처**: git post-merge hook, CI, dev 서버의 `f` 핫키.
+		* **실패 안전성**: 도중에 프로세스가 죽어 lock 없는 상태로 남아도 무해 — 다음 sync에서
+		* lock 없으면 자연스럽게 풀-싱크가 트리거되어 새 lock이 작성됨.
 		*/
-		async syncFromWatcher(event, diffFilePath) {
-			if (event !== "change" && event !== "add" && event !== "unlink") {
-				return;
+		async forceSync() {
+			const lockPath = path.join(Sonamu.apiRootPath, "sonamu.lock");
+			if (await exists(lockPath)) {
+				await unlink(lockPath);
 			}
-			if (diffFilePath.includes("/src/ssr/")) {
-				console.log(chalk.bold.yellow("SSR config changed - reloading..."));
-				if (!isTest()) {
-					await hot.invalidateFile(diffFilePath, event);
+			await this.sync();
+		}
+		/**
+		* Watcher가 batch로 모은 변경 파일들에 대해 한 번의 HMR/sync 사이클을 돕니다.
+		*
+		* HMR은 api/src 안에서 일어나는 모든 파일들에 대해서 수행합니다.
+		* checksumPatternGroup 매칭 여부와 무관하게 api/src 전체 대상입니다.
+		* 가령 api/src/utils/subset-loaders.ts 같은 파일도 변경되면 HMR은 해줍니다.
+		*
+		* Sync는 checksumPatternGroup으로 매칭되는 파일들에 대해서만 수행합니다.
+		* 여기에는 web/src나 app/src 같은 다른 target의 파일이 포함될 수 있습니다.
+		* 이런 non-api 경로의 파일들은 HMR과는 아무 상관이 없으므로, invalidate을 하지 않습니다.
+		*
+		* @param fileEvents - path → event 맵. event는 "change" | "add".
+		*/
+		async hmrAndSync(fileEvents) {
+			const hmrActionRequiredEvents = this.extractHmrActionRequiredFileEvents(fileEvents);
+			const syncTriggeringPaths = await this.extractSyncTriggeringFileEventPaths(fileEvents);
+			await this.invalidateDependentsAffectedByFileEvents(hmrActionRequiredEvents);
+			if (syncTriggeringPaths.length > 0) {
+				await this.doSyncActions(syncTriggeringPaths);
+			}
+			await this.autoloadTypes();
+			await this.autoloadModels();
+			await this.autoloadApis();
+			await this.autoloadWorkflows();
+			await this.autoloadSsrRoutes();
+			this.eventEmitter.emit("onHMRCompleted");
+		}
+		extractHmrActionRequiredFileEvents(fileEvents) {
+			const apiSrc = path.join(Sonamu.apiRootPath, "src");
+			const result = new Map();
+			for (const [filePath, event] of fileEvents) {
+				if (!filePath.startsWith(apiSrc)) {
+					continue;
 				}
-				await this.autoloadSSRRoutes();
-				this.eventEmitter.emit("onHMRCompleted");
-				return;
+				result.set(filePath, event);
+			}
+			return result;
+		}
+		async extractSyncTriggeringFileEventPaths(fileEvents) {
+			const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();
+			const syncTriggeringPaths = [];
+			for (const [diffFilePath] of fileEvents) {
+				const isInCheckPatternGroup = Object.values(checkPatternGroup).some((pattern) => minimatch(diffFilePath, pattern));
+				if (!isInCheckPatternGroup) {
+					continue;
+				}
+				syncTriggeringPaths.push(diffFilePath);
 			}
-			if (!isTest()) {
-				const invalidatedPaths = await hot.invalidateFile(diffFilePath, event);
-				if (invalidatedPaths.length > 0) {
-					console.log(chalk.bold(`🔄 Invalidated:`));
-					for (const invalidatedPath of invalidatedPaths) {
-						try {
-							const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);
-							if (removedApis.length > 0) {
-								console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`), chalk.gray(`(with ${removedApis.length} APIs)`));
-							} else {
-								console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));
+			return syncTriggeringPaths;
+		}
+		async invalidateDependentsAffectedByFileEvents(fileEvents) {
+			for (const [diffFilePath, event] of fileEvents) {
+				if (!isTest()) {
+					const invalidatedPaths = await hot.invalidateFile(diffFilePath, event);
+					if (invalidatedPaths.length > 0) {
+						console.log(chalk.bold(`🔄 Invalidated:`));
+						for (const invalidatedPath of invalidatedPaths) {
+							try {
+								const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);
+								if (removedApis.length > 0) {
+									console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`), chalk.gray(`(with ${removedApis.length} APIs)`));
+								} else {
+									console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));
+								}
+							} catch (e) {
+								console.error(e);
+								console.error(chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`));
 							}
-						} catch (e) {
-							console.error(e);
-							console.error(chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`));
 						}
 					}
 				}
+				if (!isTest() && Sonamu.config.test?.devRunner?.enabled && Sonamu.devVitestManager) {
+					Sonamu.devVitestManager.invalidateFiles([diffFilePath]);
+					console.log(chalk.dim(`Test invalidated: ${path.relative(Sonamu.apiRootPath, diffFilePath)}`));
+				}
 			}
-			if (!isTest() && Sonamu.config.test?.devRunner?.enabled && Sonamu.devVitestManager) {
-				Sonamu.devVitestManager.invalidateFiles([diffFilePath]);
-				console.log(chalk.dim(`Test invalidated: ${path.relative(Sonamu.apiRootPath, diffFilePath)}`));
-			}
-			const isInCheckPatternGroup = Object.values(getChecksumPatternGroupInAbsolutePath()).some((pattern) => minimatch(diffFilePath, pattern));
-			if (isInCheckPatternGroup) {
-				await this.doSyncActions([diffFilePath]);
-			}
-			await this.autoloadTypes();
-			await this.autoloadModels();
-			await this.autoloadApis();
-			await this.autoloadWorkflows();
-			this.eventEmitter.emit("onHMRCompleted");
 		}
 		removeInvalidatedRegisteredApis(invalidatedPath) {
 			if (!invalidatedPath.endsWith(".model.ts")) {
@@ -148,35 +177,6 @@ var init_syncer = __esmMin((() => {
 			}
 			return toRemove;
 		}
-		async copySharedToTargets(targets) {
-			const dictUtilsPath = path.join(import.meta.dirname.replace("/dist/", "/src/"), "../dict/utils.ts");
-			const dictUtilsCode = await exists(dictUtilsPath) ? await readFile(dictUtilsPath, "utf-8") : "";
-			const convertMap = {
-				baseUrl: Sonamu.config.server.baseUrl ?? `http://${Sonamu.config.server.listen?.host ?? "localhost"}:${Sonamu.config.server.listen?.port ?? 3e3}`,
-				dictUtils: dictUtilsCode
-			};
-			for (const target of targets) {
-				const srcPath = path.join(import.meta.dirname.replace("/dist/", "/src/"), `../shared/${target}.shared.ts.txt`);
-				if (!await exists(srcPath)) {
-					continue;
-				}
-				if (!await exists(path.join(Sonamu.appRootPath, target))) {
-					throw new Error(`Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`);
-				}
-				const fullText = await readFile(srcPath, "utf-8");
-				const convertedText = Object.entries(convertMap).reduce((acc, [key, value]) => acc.replace(`$[[${key}]]`, value), fullText);
-				const destPath = path.join(Sonamu.appRootPath, target, "src/services/sonamu.shared.ts");
-				if (!await exists(path.dirname(destPath))) {
-					await mkdir(path.dirname(destPath), { recursive: true });
-					console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);
-				}
-				if (await exists(destPath)) {
-					continue;
-				}
-				await writeFile(destPath, convertedText);
-				!isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));
-			}
-		}
 		async autoloadTypes() {
 			this.types = await loadTypes();
 		}
@@ -190,7 +190,7 @@ var init_syncer = __esmMin((() => {
 			this.workflows = await loadWorkflows();
 			await Sonamu.workflows.synchronize(this.workflows);
 		}
-		async autoloadSSRRoutes() {
+		async autoloadSsrRoutes() {
 			const ssrConfigPath = path.join(Sonamu.apiRootPath, "src/ssr");
 			const { clearSSRRoutes } = await import("../ssr/index.js");
 			clearSSRRoutes();
@@ -212,51 +212,78 @@ var init_syncer = __esmMin((() => {
 		/**
 		* 실제 싱크를 수행하는 본체입니다.
 		* 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.
+		*
 		* @param diffFilePaths - 변경된 파일들의 절대 경로 목록
 		* @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)
 		*/
 		async doSyncActions(diffFilePaths) {
 			const diffGroups = this.calculateDiffGroups(diffFilePaths);
 			const diffTypes = Object.keys(diffGroups);
-			if (diffTypes.includes("entity") || diffTypes.includes("types")) {
-				await this.handleTruthSourceChanges(diffGroups, diffTypes);
+			const { changeMatches, nothingMatches, unhandledPaths } = this.changeMatcher(diffTypes, diffGroups);
+			if (changeMatches("entity", "types")) {
+				await this.handleTruthSourceChanges(diffGroups);
 			}
-			if (diffTypes.includes("types") || diffTypes.includes("functions") || diffTypes.includes("generated")) {
-				await this.handleSyncableFileChanges(diffGroups);
-			}
-			if (diffTypes.includes("model") || diffTypes.includes("frame")) {
+			if (changeMatches("model", "frame")) {
 				await this.handleImplementationChanges(diffGroups);
 			}
-			if (diffTypes.includes("config")) {
-				await actionSyncConfig();
+			if (changeMatches("types", "functions")) {
+				await this.handleAuxiliarySymbolChanges(diffGroups);
+			}
+			if (changeMatches("config")) {
+				await this.handleConfigChanges(diffGroups);
 			}
-			if (diffTypes.includes("workflow")) {
-				await this.autoloadWorkflows();
+			if (changeMatches("i18n", "entity", "config")) {
+				await this.handleSonamuDictionaryRelatedChanges(diffGroups);
 			}
-			if (diffTypes.includes("i18n") || diffTypes.includes("entity") || diffTypes.includes("config")) {
-				await this.syncSD();
+			if (nothingMatches()) {
+				await this.handleDrifts(unhandledPaths());
 			}
 			return { diffTypes };
 		}
 		calculateDiffGroups(diffFiles) {
-			const fileTypes = Object.keys(checksumPatternGroup);
+			const patternGroup = getChecksumPatternGroup();
+			const fileTypes = Object.keys(patternGroup);
 			return group(diffFiles, (filePath) => {
-				const srcIndex = filePath.indexOf("/src/");
-				if (srcIndex === -1) return "unknown";
-				const relativePath = filePath.slice(srcIndex + 1);
+				const relativePath = path.relative(Sonamu.appRootPath, filePath);
+				if (relativePath.startsWith("..")) return "unknown";
 				for (const fileType of fileTypes) {
-					if (minimatch(relativePath, checksumPatternGroup[fileType])) {
+					if (minimatch(relativePath, patternGroup[fileType])) {
 						return fileType;
 					}
 				}
 				return "unknown";
 			});
 		}
-		async handleTruthSourceChanges(diffGroups, diffTypes) {
-			Naite.t("handleTruthSourceChanges", {
-				diffGroups,
-				diffTypes
-			});
+		changeMatcher(diffTypes, diffGroups) {
+			const handled = new Set();
+			/**
+			* 변경 사항이 인자로 받은 FileType들 중 하나 이상을 포함하는지 확인합니다.
+			* 가령 ["entity"]가 변경된 호출에서 changeMatches("entity")는 trye를 반환하며,
+			* ["types", "i18n"]이 변경된 호출에서 changeMatches("types", "functions")도 true를 반환하지만,
+			* ["functions"]가 변경된 호출에서 changeMatches("frame")은 false를 반환합니다.
+			* @param types
+			*/
+			const changeMatches = (...types) => {
+				const matching = types.filter((t) => diffTypes.includes(t));
+				matching.forEach((t) => handled.add(t));
+				return matching.length > 0;
+			};
+			/**
+			* changeMatches로 매칭된 것이 하나도 없는지 여부를 가져옵니다.
+			*/
+			const nothingMatches = () => handled.size === 0;
+			/**
+			* 어떤 changeMatches 호출에도 걸리지 않은 FileType들의 실제 파일 경로를 모아서 반환합니다.
+			*/
+			const unhandledPaths = () => diffTypes.filter((t) => !handled.has(t)).flatMap((t) => diffGroups[t] ?? []);
+			return {
+				changeMatches,
+				nothingMatches,
+				unhandledPaths
+			};
+		}
+		async handleTruthSourceChanges(diffGroups) {
+			Naite.t("handleTruthSourceChanges", { diffGroups });
 			await EntityManager.reload();
 			const entityPath = diffGroups.entity?.at(0);
 			if (entityPath !== undefined) {
@@ -264,22 +291,12 @@ var init_syncer = __esmMin((() => {
 				const entity = EntityManager.get(entityId);
 				const typeFilePath = path.join(Sonamu.apiRootPath, `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`);
 				if (entity.parentId === undefined && !await exists(typeFilePath)) {
-					await generateTemplate("init_types", { entityId });
+					const types = await actionGenerateInitialTypes(entityId);
+					await actionSyncFilesToTargets(types);
 				}
 			}
-			await actionGenerateSchemas();
-			diffGroups.generated = unique([...diffGroups.generated ?? [], path.join(Sonamu.apiRootPath, "src/application/sonamu.generated.ts")]);
-			diffTypes.push("generated");
-		}
-		async handleSyncableFileChanges(diffGroups) {
-			const tsPaths = unique([
-				...diffGroups.types ?? [],
-				...diffGroups.functions ?? [],
-				...diffGroups.generated ?? []
-			]);
-			Naite.t("handleSyncableFileChanges", { diffGroups });
-			await actionSyncFilesToTargets(tsPaths);
-			return [];
+			const generated = await actionGenerateSchemas();
+			await actionSyncFilesToTargets(generated);
 		}
 		async handleImplementationChanges(diffGroups) {
 			Naite.t("handleImplementationChanges", { diffGroups });
@@ -297,7 +314,28 @@ var init_syncer = __esmMin((() => {
 			});
 			await actionGenerateServices(params);
 			await actionGenerateHttps();
-			await actionGenerateSsr();
+			const queries = await actionGenerateSsrQueries();
+			await actionSyncFilesToTargets(queries);
+		}
+		async handleAuxiliarySymbolChanges(diffGroups) {
+			Naite.t("handleAuxiliarySymbolChanges", { diffGroups });
+			const tsPaths = unique([...diffGroups.types ?? [], ...diffGroups.functions ?? []]);
+			await actionSyncFilesToTargets(tsPaths);
+		}
+		async handleConfigChanges(_) {
+			await actionSyncConfig();
+		}
+		async handleSonamuDictionaryRelatedChanges(_) {
+			await actionSyncSonamuDictionary();
+		}
+		async handleDrifts(drifts) {
+			if (drifts.length > 0) {
+				console.warn(chalk.yellow("⚠️ Sonamu가 자동 생성한 파일에 대한 변경이 감지되었습니다. 파일이 Sonamu watcher 외부에서 변경된 것으로 추정됩니다."));
+				for (const p of drifts) {
+					console.warn(chalk.yellow(`  - ${path.relative(Sonamu.appRootPath, p)}`));
+				}
+				console.warn(chalk.dim("  → `pnpm sonamu sync --force`를 권장합니다."));
+			}
 		}
 		/**
 		* 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.
@@ -377,48 +415,10 @@ var init_syncer = __esmMin((() => {
 		async renewChecksums() {
 			return await renewChecksums();
 		}
-		/**
-		* SD(Sonamu Dictionary) 템플릿을 생성합니다.
-		*/
-		async syncSD() {
-			const { targets } = Sonamu.config.sync;
-			const i18nConfig = Sonamu.config.i18n;
-			const targetList = ["api", ...targets];
-			const apiI18nDir = path.join(Sonamu.appRootPath, Sonamu.config.api.dir, "src/i18n");
-			for (const target of targetList) {
-				try {
-					if (target !== "api") {
-						await this.syncLocaleFiles(target, apiI18nDir, i18nConfig.supportedLocales);
-					}
-					await generateTemplate("sd", { target }, { overwrite: true });
-				} catch (e) {
-					console.error(`Failed to generate SD template for ${target}:`, e);
-				}
-			}
-		}
-		/**
-		* api의 locale 파일을 web/app으로 복사합니다.
-		*/
-		async syncLocaleFiles(target, apiI18nDir, locales) {
-			const targetI18nDir = path.join(Sonamu.appRootPath, target, "src/i18n");
-			await mkdir(targetI18nDir, { recursive: true });
-			for (const locale of locales) {
-				const sourceFile = path.join(apiI18nDir, `${locale}.ts`);
-				const targetFile = path.join(targetI18nDir, `${locale}.ts`);
-				const syncHeader = [
-					"/**",
-					" * @generated",
-					" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.",
-					" */"
-				].join("\n");
-				await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);
-				!isTest() && console.log(chalk.bold("Copied: ") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));
-			}
-		}
 	};
 }));
 
 //#endregion
 init_syncer();
 export { Syncer, init_syncer };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer.js","names":["SyncerActions.actionSyncConfig","SyncerActions.actionGenerateSchemas","SyncerActions.actionSyncFilesToTargets","params: {\n      namesRecord: EntityNamesRecord;\n    }[]","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsr","keys: TemplateKey[]","p","target"],"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import assert from \"assert\";\nimport { EventEmitter } from \"events\";\nimport { mkdir, readFile, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport { hot } from \"@sonamu-kit/hmr-hook\";\nimport chalk from \"chalk\";\nimport { minimatch } from \"minimatch\";\nimport { group, 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 { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\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 { copyFileWithReplaceCoreToShared, exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\nimport { findChangedFilesUsingChecksums, renewChecksums } from \"./checksum\";\nimport { generateTemplate, renderTemplate } from \"./code-generator\";\nimport { createEntity, delEntity } from \"./entity-operations\";\nimport { checksumPatternGroup, getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { type FileType } from \"./file-patterns\";\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 DiffGroups = {\n  [key in FileType]: AbsolutePath[];\n};\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   * sonamu.shared.ts는 파일이 없을 때만 1회 생성하고, 이후에는 덮어쓰지 않습니다.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    const { targets } = Sonamu.config.sync;\n\n    // sonamu.shared.ts는 파일이 없을 때만 1회 생성합니다.\n    await this.copySharedToTargets(targets);\n\n    // 그 다음부터는 변경된 파일을 찾아서 동기화 작업을 실행합니다.\n    const changedFiles = await findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\n      console.log(chalk.black.bgGreen(centerText(\"All files are synced!\")));\n\n      // 변경사항이 없어도 SSR 템플릿은 생성 (초기 설정 시, 이미 존재하면 스킵)\n      try {\n        await generateTemplate(\"queries\", {}, { overwrite: false });\n        await generateTemplate(\"entry_server\", {}, { overwrite: false });\n      } catch (e) {\n        // 파일이 이미 존재하면 무시\n        if (!(e instanceof AlreadyProcessedException)) {\n          console.error(\"Failed to generate SSR templates:\", e);\n        }\n      }\n\n      return;\n    }\n\n    // 만약 싱크 중에 프로세스가 죽으면 꼬여버리기 때문에,\n    // 시그널에도 잠시 버틸 수 있는 환경 속에서 싱크를 실행합니다.\n    await runWithGracefulShutdown(\n      async () => {\n        // 얘가 싱크 작업 수행하는 본체입니다.\n        await this.doSyncActions(changedFiles);\n\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 },\n    );\n  }\n\n  /**\n   * Watcher가 감지한 파일 변경 사항에 대해 싱크를 진행합니다.\n   * 주어진 변경 파일들 중 체크섬 관리 대상인 것들만 가져다가 싱크를 진행합니다.\n   * 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.\n   * @param diffFilePath - 변경 파일들. 프로젝트 루트부터 \"src/\" 또는 \"dist/\"로 시작하는 상대 경로입니다. 예시: \"src/application/user/user.model.ts\"\n   */\n  async syncFromWatcher(event: string, diffFilePath: AbsolutePath): Promise<void> {\n    if (event !== \"change\" && event !== \"add\" && event !== \"unlink\") {\n      return;\n    }\n\n    // SSR 설정 파일 변경 감지\n    if (diffFilePath.includes(\"/src/ssr/\")) {\n      console.log(chalk.bold.yellow(\"SSR config changed - reloading...\"));\n      // SSR 파일도 invalidate 후 reload\n      if (!isTest()) {\n        await hot.invalidateFile(diffFilePath, event);\n      }\n      await this.autoloadSSRRoutes();\n      this.eventEmitter.emit(\"onHMRCompleted\");\n      return;\n    }\n\n    // 일단 변경된 파일과 dependent 파일들을 invalidate 합니다.\n    // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.\n    // 그러니 안심하고 invalidate 해도 됩니다.\n    // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.\n    if (!isTest()) {\n      const invalidatedPaths = (await hot.invalidateFile(diffFilePath, event)) 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    const isInCheckPatternGroup = Object.values(getChecksumPatternGroupInAbsolutePath()).some(\n      (pattern) => minimatch(diffFilePath, pattern),\n    );\n\n    // 할 일(sync)이 있으면 합니다.\n    if (isInCheckPatternGroup) {\n      await this.doSyncActions([diffFilePath]);\n    }\n\n    // 싱크 작업이 끝나면 모든 모듈을 로드합니다.\n    // hmr-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n    await this.autoloadWorkflows();\n\n    this.eventEmitter.emit(\"onHMRCompleted\");\n  }\n\n  removeInvalidatedRegisteredApis(\n    invalidatedPath: AbsolutePath,\n  ): (typeof registeredApis)[number][] {\n    if (!invalidatedPath.endsWith(\".model.ts\" /*소스 코드를 다루는 상황이니 .ts 경로로 봅니다.*/)) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const toRemove = registeredApis.filter((api) => api.modelName === `${entityId}Model`);\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 copySharedToTargets(targets: string[]): Promise<void> {\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 exists(dictUtilsPath))\n      ? await 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 exists(srcPath))) {\n        continue;\n      }\n      if (!(await exists(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 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 exists(path.dirname(destPath)))) {\n        await 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 exists(destPath)) {\n        continue;\n      }\n\n      await writeFile(destPath, convertedText);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Copied: \") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)),\n        );\n    }\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 exists(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   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록\n   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)\n   */\n  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: string[] }> {\n    const diffGroups = this.calculateDiffGroups(diffFilePaths);\n    const diffTypes = Object.keys(diffGroups) as FileType[];\n\n    // Single source of truth가 변경된 경우\n    if (diffTypes.includes(\"entity\") || diffTypes.includes(\"types\")) {\n      await this.handleTruthSourceChanges(diffGroups, diffTypes);\n    }\n\n    // 타겟으로 복사만 하면 되는 파일이 변경된 경우\n    if (\n      diffTypes.includes(\"types\") ||\n      diffTypes.includes(\"functions\") ||\n      diffTypes.includes(\"generated\")\n    ) {\n      await this.handleSyncableFileChanges(diffGroups);\n    }\n\n    // 모델/프레임 구현체가 변경된 경우\n    if (diffTypes.includes(\"model\") || diffTypes.includes(\"frame\")) {\n      await this.handleImplementationChanges(diffGroups);\n    }\n\n    // 설정 파일이 변경된 경우\n    if (diffTypes.includes(\"config\")) {\n      await SyncerActions.actionSyncConfig();\n    }\n\n    // 워크플로우 파일이 변경된 경우\n    if (diffTypes.includes(\"workflow\")) {\n      await this.autoloadWorkflows();\n    }\n\n    // i18n 관련 파일이 변경된 경우\n    // - i18n/*.ts: locale 번역 파일\n    // - entity.json: entity labels\n    // - sonamu.config.ts: i18n 설정 (defaultLocale, supportedLocales)\n    if (\n      diffTypes.includes(\"i18n\") ||\n      diffTypes.includes(\"entity\") ||\n      diffTypes.includes(\"config\")\n    ) {\n      await this.syncSD();\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {\n    const fileTypes = Object.keys(checksumPatternGroup) as FileType[];\n\n    return group(diffFiles, (filePath) => {\n      // 절대 경로에서 src/로 시작하는 상대 경로 부분을 추출합니다.\n      const srcIndex = filePath.indexOf(\"/src/\");\n      if (srcIndex === -1) return \"unknown\";\n      const relativePath = filePath.slice(srcIndex + 1); // \"src/...\" 형태\n\n      for (const fileType of fileTypes) {\n        if (minimatch(relativePath, checksumPatternGroup[fileType])) {\n          return fileType;\n        }\n      }\n      return \"unknown\";\n    }) as unknown as DiffGroups;\n  }\n\n  async handleTruthSourceChanges(diffGroups: DiffGroups, diffTypes: string[]): Promise<void> {\n    Naite.t(\"handleTruthSourceChanges\", { diffGroups, diffTypes });\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      // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.\n      const typeFilePath = path.join(\n        Sonamu.apiRootPath,\n        `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,\n      );\n      if (entity.parentId === undefined && !(await exists(typeFilePath))) {\n        await generateTemplate(\"init_types\", { entityId });\n      }\n    }\n\n    await SyncerActions.actionGenerateSchemas();\n\n    diffGroups.generated = unique([\n      ...(diffGroups.generated ?? []),\n      path.join(Sonamu.apiRootPath, \"src/application/sonamu.generated.ts\") as AbsolutePath,\n    ]);\n    diffTypes.push(\"generated\");\n  }\n\n  async handleSyncableFileChanges(diffGroups: DiffGroups): Promise<FileType[]> {\n    const tsPaths = unique([\n      ...(diffGroups.types ?? []),\n      ...(diffGroups.functions ?? []),\n      ...(diffGroups.generated ?? []),\n    ]);\n    Naite.t(\"handleSyncableFileChanges\", { diffGroups });\n\n    // console.log(\n    //   chalk.gray(\n    //     `[Processing] Handling types/functions/generated changes: ${tsPaths.map((p) => path.relative(Sonamu.apiRootPath, p)).join(\", \")}`\n    //   )\n    // );\n\n    await SyncerActions.actionSyncFilesToTargets(tsPaths);\n\n    return [];\n  }\n\n  async handleImplementationChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleImplementationChanges\", { diffGroups });\n    const mergedGroup = [...(diffGroups.model ?? []), ...(diffGroups.frame ?? [])];\n\n    // console.log(\n    //   chalk.gray(\n    //     `[Processing] Handling model/frame changes: ${mergedGroup.map((p) => path.relative(Sonamu.apiRootPath, p)).join(\", \")}`\n    //   )\n    // );\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.actionGenerateSsr();\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 exists(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 exists(\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 exists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p),\n            );\n          });\n        } else {\n          result[key] = await exists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      {} as Record<`${TemplateKey}${string}`, boolean>,\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  /**\n   * SD(Sonamu Dictionary) 템플릿을 생성합니다.\n   */\n  async syncSD(): Promise<void> {\n    const { targets } = Sonamu.config.sync;\n    const i18nConfig = Sonamu.config.i18n;\n\n    const targetList = [\"api\", ...targets] 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 this.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   */\n  private async 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 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      !isTest() &&\n        console.log(chalk.bold(\"Copied: \") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));\n    }\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","syncTriggeringPaths: AbsolutePath[]","SyncerActions.actionGenerateInitialTypes","SyncerActions.actionSyncFilesToTargets","SyncerActions.actionGenerateSchemas","params: {\n      namesRecord: EntityNamesRecord;\n    }[]","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsrQueries","SyncerActions.actionSyncConfig","SyncerActions.actionSyncSonamuDictionary","keys: TemplateKey[]","p","target"],"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import assert from \"assert\";\nimport { EventEmitter } from \"events\";\nimport { unlink } from \"fs/promises\";\nimport path from \"path\";\n\nimport { hot } from \"@sonamu-kit/hmr-hook\";\nimport chalk from \"chalk\";\nimport { minimatch } from \"minimatch\";\nimport { group, 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 { exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\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 { 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 DiffGroups = {\n  [key in FileType]: AbsolutePath[];\n};\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 할 때 실행됩니다. 이후에는 syncFromWatcher 경로를 타요.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.\n    // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.\n    // 그래서 아무 때나 그냥 돌려주면 되는데, syncFromWatcher에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.\n    await SyncerActions.actionCopySharedToTargetsIfNotExists();\n    await SyncerActions.actionGenerateSsrEntryServerIfNotExists();\n\n    // 바뀐 것이 없으면 그냥 넘어가요.\n    const changedFiles = await findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\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\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 },\n    );\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 exists(lockPath)) {\n      await 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\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 = (await hot.invalidateFile(diffFilePath, event)) 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    if (!invalidatedPath.endsWith(\".model.ts\" /*소스 코드를 다루는 상황이니 .ts 경로로 봅니다.*/)) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const toRemove = registeredApis.filter((api) => api.modelName === `${entityId}Model`);\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 exists(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 = Object.keys(diffGroups) as FileType[];\n\n    // 여기는 별로 중요한 파트는 아닙니다.\n    // 아래의 if 전개를 깔끔하게 하려고 만든 DSL 같은 거라서, 무시하셔도 됩니다.\n    const { changeMatches, nothingMatches, unhandledPaths } = 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(diffGroups);\n    }\n\n    if (changeMatches(\"i18n\", \"entity\" /*레이블*/, \"config\" /*defaultLocale등*/)) {\n      await this.handleSonamuDictionaryRelatedChanges(diffGroups);\n    }\n\n    if (nothingMatches()) {\n      // 파일 변경은 감지되었으나 저 위 어느 changeMatches에도 걸리지 않은 파일들이 drifts입니다.\n      // syncer는 소스의 변경에는 반응하지만 산출물의 변경(drift)에는 직접적으로 반응하지 않습니다.\n      // 대신 이 drift에 대해 경고 정도만 출력해줍니다.\n      await this.handleDrifts(unhandledPaths());\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {\n    const patternGroup = getChecksumPatternGroup();\n    const fileTypes = Object.keys(patternGroup) as FileType[];\n\n    return group(diffFiles, (filePath) => {\n      // 절대 경로 → appRoot 기준 상대 경로 (예: \"api/src/...\", \"web/src/...\")\n      const relativePath = path.relative(Sonamu.appRootPath, filePath);\n      if (relativePath.startsWith(\"..\")) return \"unknown\";\n\n      for (const fileType of fileTypes) {\n        if (minimatch(relativePath, patternGroup[fileType])) {\n          return fileType;\n        }\n      }\n      return \"unknown\";\n    }) as unknown as 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로 매칭된 것이 하나도 없는지 여부를 가져옵니다.\n     */\n    const nothingMatches = () => handled.size === 0;\n\n    /**\n     * 어떤 changeMatches 호출에도 걸리지 않은 FileType들의 실제 파일 경로를 모아서 반환합니다.\n     */\n    const unhandledPaths = (): AbsolutePath[] =>\n      diffTypes.filter((t) => !handled.has(t)).flatMap((t) => diffGroups[t] ?? []);\n\n    return { changeMatches, nothingMatches, unhandledPaths };\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 = 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 exists(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가 만들어집니다.\n    const generated = await SyncerActions.actionGenerateSchemas();\n\n    // 그걸 target들에도 보내요.\n    await SyncerActions.actionSyncFilesToTargets(generated);\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    // services.generated.ts를 target들에, sonamu.generated.http를 api에 만들어줘요.\n    await SyncerActions.actionGenerateServices(params);\n    await SyncerActions.actionGenerateHttps();\n\n    // queries.generated.ts가 만들어집니다.\n    const queries = await SyncerActions.actionGenerateSsrQueries();\n\n    // 그걸 target들에도 보내요.\n    await SyncerActions.actionSyncFilesToTargets(queries);\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(_: DiffGroups): Promise<void> {\n    await SyncerActions.actionSyncConfig();\n  }\n\n  async handleSonamuDictionaryRelatedChanges(_: DiffGroups): Promise<void> {\n    await SyncerActions.actionSyncSonamuDictionary();\n  }\n\n  async handleDrifts(drifts: AbsolutePath[]): Promise<void> {\n    if (drifts.length > 0) {\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   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.\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 exists(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 exists(\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 exists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p),\n            );\n          });\n        } else {\n          result[key] = await exists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      {} as Record<`${TemplateKey}${string}`, boolean>,\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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"}