sonamu 0.8.26 → 0.9.0

package/dist/syncer/syncer.js

@@ -1,497 +1,431 @@
-import { hot } from "@sonamu-kit/hmr-hook";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { AlreadyProcessedException, init_so_exceptions } from "../exceptions/so-exceptions.js";
+import { init_controller, isTest } from "../utils/controller.js";
+import { copyFileWithReplaceCoreToShared, 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 { 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 inflection from "inflection";
+import { group, unique } from "radashi";
 import assert from "assert";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
 import chalk from "chalk";
 import { EventEmitter } from "events";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import inflection from "inflection";
+import { hot } from "@sonamu-kit/hmr-hook";
 import { minimatch } from "minimatch";
-import path from "path";
-import { group, unique } from "radashi";
-import { registeredApis } from "../api/decorators.js";
-import { Sonamu } from "../api/sonamu.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { AlreadyProcessedException } from "../exceptions/so-exceptions.js";
-import { Naite } from "../naite/naite.js";
-import { TemplateManager } from "../template/template-manager.js";
-import { TemplateKey } from "../types/types.js";
-import { mapAsync, reduceAsync } from "../utils/async-utils.js";
-import { centerText } from "../utils/console-util.js";
-import { isTest } from "../utils/controller.js";
-import { copyFileWithReplaceCoreToShared, exists } from "../utils/fs-utils.js";
-import { runWithGracefulShutdown } from "../utils/process-utils.js";
-import { findChangedFilesUsingChecksums, renewChecksums } from "./checksum.js";
-import { generateTemplate, renderTemplate } from "./code-generator.js";
-import { createEntity, delEntity } from "./entity-operations.js";
-import { checksumPatternGroup, getChecksumPatternGroupInAbsolutePath } from "./file-patterns.js";
-import { loadApis, loadModels, loadTypes, loadWorkflows } from "./module-loader.js";
-import * as SyncerActions from "./syncer-actions.js";
-export class Syncer {
-    apis = [];
-    types = {};
-    models = {};
-    workflows = new Map();
-    eventEmitter = new EventEmitter();
-    /**
-   * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
-   * sonamu.shared.ts는 파일이 없을 때만 1회 생성하고, 이후에는 덮어쓰지 않습니다.
-   * @returns
-   */ async sync() {
-        const { targets } = Sonamu.config.sync;
-        // sonamu.shared.ts는 파일이 없을 때만 1회 생성합니다.
-        await this.copySharedToTargets(targets);
-        // 그 다음부터는 변경된 파일을 찾아서 동기화 작업을 실행합니다.
-        const changedFiles = await findChangedFilesUsingChecksums();
-        if (changedFiles.length === 0) {
-            console.log(chalk.black.bgGreen(centerText("All files are synced!")));
-            // 변경사항이 없어도 SSR 템플릿은 생성 (초기 설정 시, 이미 존재하면 스킵)
-            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 ()=>{
-            // 얘가 싱크 작업 수행하는 본체입니다.
-            await this.doSyncActions(changedFiles);
-            // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.
-            await renewChecksums();
-        }, {
-            whenThisHappens: "SIGUSR2",
-            waitForUpTo: 20000
-        });
-    }
-    /**
-   * Watcher가 감지한 파일 변경 사항에 대해 싱크를 진행합니다.
-   * 주어진 변경 파일들 중 체크섬 관리 대상인 것들만 가져다가 싱크를 진행합니다.
-   * 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.
-   * @param diffFilePath - 변경 파일들. 프로젝트 루트부터 "src/" 또는 "dist/"로 시작하는 상대 경로입니다. 예시: "src/application/user/user.model.ts"
-   */ async syncFromWatcher(event, diffFilePath) {
-        if (event !== "change" && event !== "add" && event !== "unlink") {
-            return;
-        }
-        // SSR 설정 파일 변경 감지
-        if (diffFilePath.includes("/src/ssr/")) {
-            console.log(chalk.bold.yellow("SSR config changed - reloading..."));
-            // SSR 파일도 invalidate 후 reload
-            if (!isTest()) {
-                await hot.invalidateFile(diffFilePath, event);
-            }
-            await this.autoloadSSRRoutes();
-            this.eventEmitter.emit("onHMRCompleted");
-            return;
-        }
-        // 일단 변경된 파일과 dependent 파일들을 invalidate 합니다.
-        // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.
-        // 그러니 안심하고 invalidate 해도 됩니다.
-        // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.
-        if (!isTest()) {
-            const invalidatedPaths = await hot.invalidateFile(diffFilePath, event);
-            if (invalidatedPaths.length > 0) {
-                console.log(chalk.bold(`🔄 Invalidated:`));
-                for (const invalidatedPath of invalidatedPaths){
-                    try {
-                        // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.
-                        // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.
-                        // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.
-                        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}`));
-                    }
-                }
-            }
-        }
-        // devRunner 활성화 시, 변경된 소스 파일을 Vitest 모듈 그래프에서도 무효화합니다.
-        // Vite의 moduleGraph.invalidateModule()이 importer 방향으로 재귀적 cascade하므로,
-        // 소스 파일 하나만 무효화하면 이를 import하는 테스트 파일도 자동으로 무효화됩니다.
-        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));
-        // 할 일(sync)이 있으면 합니다.
-        if (isInCheckPatternGroup) {
-            await this.doSyncActions([
-                diffFilePath
-            ]);
-        }
-        // 싱크 작업이 끝나면 모든 모듈을 로드합니다.
-        // hmr-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.
-        await this.autoloadTypes();
-        await this.autoloadModels();
-        await this.autoloadApis();
-        await this.autoloadWorkflows();
-        this.eventEmitter.emit("onHMRCompleted");
-    }
-    removeInvalidatedRegisteredApis(invalidatedPath) {
-        if (!invalidatedPath.endsWith(".model.ts" /*소스 코드를 다루는 상황이니 .ts 경로로 봅니다.*/ )) {
-            return [];
-        }
-        const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);
-        const toRemove = registeredApis.filter((api)=>api.modelName === `${entityId}Model`);
-        for (const api of toRemove){
-            const idx = registeredApis.indexOf(api);
-            if (idx !== -1) {
-                registeredApis.splice(idx, 1);
-            }
-        }
-        return toRemove;
-    }
-    async copySharedToTargets(targets) {
-        // plural.ts 내용을 읽어서 shared 파일에 삽입합니다.
-        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 ?? 3000}`,
-            dictUtils: dictUtilsCode
-        };
-        for (const target of targets){
-            // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.
-            // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.
-            // 따라서 /src/에서 찾습니다.
-            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);
-            // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.
-            const destPath = path.join(Sonamu.appRootPath, target, "src/services/sonamu.shared.ts");
-            // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.
-            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.`);
-            }
-            // 파일이 이미 존재하면 건너뜁니다.
-            // sonamu.shared.ts는 프로젝트에서 자유롭게 커스터마이징할 수 있어야 하므로,
-            // 최초 1회만 생성하고 이후에는 덮어쓰지 않습니다.
-            // 템플릿 내용($[[dictUtils]] 등)이 변경되었을 때 반영이 필요하면,
-            // 해당 파일을 삭제한 뒤 `pnpm sonamu sync`로 재생성하면 됩니다.
-            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();
-    }
-    async autoloadModels() {
-        this.models = await loadModels();
-    }
-    async autoloadApis() {
-        this.apis = await loadApis();
-    }
-    async autoloadWorkflows() {
-        this.workflows = await loadWorkflows();
-        await Sonamu.workflows.synchronize(this.workflows);
-    }
-    async autoloadSSRRoutes() {
-        const ssrConfigPath = path.join(Sonamu.apiRootPath, "src/ssr");
-        // 기존 routes 초기화
-        const { clearSSRRoutes } = await import("../ssr/index.js");
-        clearSSRRoutes();
-        // ssr 폴더 없으면 스킵
-        if (!await exists(ssrConfigPath)) {
-            return;
-        }
-        // ssr 폴더 안의 모든 .ts 파일 로드
-        const { globAsync } = await import("../utils/async-utils.js");
-        const { importMembers } = await import("../utils/esm-utils.js");
-        const { runtimePath } = await import("../utils/path-utils.js");
-        // runtimePath를 사용하여 개발/프로덕션 환경에 맞는 확장자 처리
-        const files = await globAsync(path.join(ssrConfigPath, runtimePath("**/*.ts")));
-        for (const file of files){
-            try {
-                // importMembers를 사용하면 파일의 side effect(registerSSR 호출)가 실행됨
-                await importMembers(file);
-            } catch (e) {
-                console.error(`Failed to load SSR route: ${file}`, e);
-            }
-        }
-    }
-    /**
-   * 실제 싱크를 수행하는 본체입니다.
-   * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.
-   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록
-   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)
-   */ async doSyncActions(diffFilePaths) {
-        const diffGroups = this.calculateDiffGroups(diffFilePaths);
-        const diffTypes = Object.keys(diffGroups);
-        // Single source of truth가 변경된 경우
-        if (diffTypes.includes("entity") || diffTypes.includes("types")) {
-            await this.handleTruthSourceChanges(diffGroups, diffTypes);
-        }
-        // 타겟으로 복사만 하면 되는 파일이 변경된 경우
-        if (diffTypes.includes("types") || diffTypes.includes("functions") || diffTypes.includes("generated")) {
-            await this.handleSyncableFileChanges(diffGroups);
-        }
-        // 모델/프레임 구현체가 변경된 경우
-        if (diffTypes.includes("model") || diffTypes.includes("frame")) {
-            await this.handleImplementationChanges(diffGroups);
-        }
-        // 설정 파일이 변경된 경우
-        if (diffTypes.includes("config")) {
-            await SyncerActions.actionSyncConfig();
-        }
-        // 워크플로우 파일이 변경된 경우
-        if (diffTypes.includes("workflow")) {
-            await this.autoloadWorkflows();
-        }
-        // i18n 관련 파일이 변경된 경우
-        // - i18n/*.ts: locale 번역 파일
-        // - entity.json: entity labels
-        // - sonamu.config.ts: i18n 설정 (defaultLocale, supportedLocales)
-        if (diffTypes.includes("i18n") || diffTypes.includes("entity") || diffTypes.includes("config")) {
-            await this.syncSD();
-        }
-        return {
-            diffTypes
-        };
-    }
-    calculateDiffGroups(diffFiles) {
-        const fileTypes = Object.keys(checksumPatternGroup);
-        return group(diffFiles, (filePath)=>{
-            // 절대 경로에서 src/로 시작하는 상대 경로 부분을 추출합니다.
-            const srcIndex = filePath.indexOf("/src/");
-            if (srcIndex === -1) return "unknown";
-            const relativePath = filePath.slice(srcIndex + 1); // "src/..." 형태
-            for (const fileType of fileTypes){
-                if (minimatch(relativePath, checksumPatternGroup[fileType])) {
-                    return fileType;
-                }
-            }
-            return "unknown";
-        });
-    }
-    async handleTruthSourceChanges(diffGroups, diffTypes) {
-        Naite.t("handleTruthSourceChanges", {
-            diffGroups,
-            diffTypes
-        });
-        await EntityManager.reload();
-        // types 생성(entity 새로 추가된 경우)
-        // parentId가 없고, types가 없는 경우에만 생성
-        const entityPath = diffGroups.entity?.at(0);
-        if (entityPath !== undefined) {
-            const entityId = EntityManager.getEntityIdFromPath(entityPath);
-            const entity = EntityManager.get(entityId);
-            // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.
-            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
-                });
-            }
-        }
-        await SyncerActions.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
-        });
-        // console.log(
-        //   chalk.gray(
-        //     `[Processing] Handling types/functions/generated changes: ${tsPaths.map((p) => path.relative(Sonamu.apiRootPath, p)).join(", ")}`
-        //   )
-        // );
-        await SyncerActions.actionSyncFilesToTargets(tsPaths);
-        return [];
-    }
-    async handleImplementationChanges(diffGroups) {
-        Naite.t("handleImplementationChanges", {
-            diffGroups
-        });
-        const mergedGroup = [
-            ...diffGroups.model ?? [],
-            ...diffGroups.frame ?? []
-        ];
-        // console.log(
-        //   chalk.gray(
-        //     `[Processing] Handling model/frame changes: ${mergedGroup.map((p) => path.relative(Sonamu.apiRootPath, p)).join(", ")}`
-        //   )
-        // );
-        // generated_http.template.ts에서 syncer.types를 씁니다.
-        // service.template.ts에서 syncer.apis를 씁니다.
-        await this.autoloadModels();
-        await this.autoloadTypes();
-        await this.autoloadApis();
-        const params = mergedGroup.map((modelPath)=>{
-            if (modelPath.endsWith(".model.ts")) {
-                const entityId = EntityManager.getEntityIdFromPath(modelPath);
-                assert(entityId);
-                return {
-                    namesRecord: EntityManager.getNamesFromId(entityId)
-                };
-            }
-            if (modelPath.endsWith(".frame.ts")) {
-                const [, frameName] = modelPath.match(/.+\/(.+)\.frame\.ts$/) ?? [];
-                assert(frameName);
-                // frameName을 PascalCase로 변환 (dashboard -> Dashboard)
-                const frameId = inflection.camelize(frameName);
-                return {
-                    namesRecord: EntityManager.getNamesFromId(frameId)
-                };
-            }
-            throw new Error("not reachable");
-        });
-        await SyncerActions.actionGenerateServices(params);
-        await SyncerActions.actionGenerateHttps();
-        await SyncerActions.actionGenerateSsr();
-    }
-    /**
-   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.
-   * @param entityId 엔티티 ID
-   * @param templateKey 템플릿 키
-   * @param enumId 열거형 ID
-   * @returns 생성된 코드가 존재하는지 여부
-   */ async checkExistsGenCode(entityId, templateKey, enumId) {
-        const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(EntityManager.getNamesFromId(entityId), enumId);
-        const subPath = path.join(target, genPath);
-        const fullPath = path.join(Sonamu.appRootPath, subPath);
-        return {
-            subPath,
-            fullPath,
-            isExists: await exists(fullPath)
-        };
-    }
-    /**
-   * 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.
-   * @param entityId 엔티티 ID
-   * @param enums 열거형 레이블
-   * @returns 생성된 코드가 존재하는지 여부
-   */ async checkExists(entityId, enums) {
-        const keys = TemplateKey.options;
-        const names = EntityManager.getNamesFromId(entityId);
-        const enumsKeys = Object.keys(enums).filter((name)=>name !== names.constant);
-        return await reduceAsync(keys, async (result, key)=>{
-            const tpl = TemplateManager.get(key);
-            if (key.startsWith("view_enums")) {
-                await mapAsync(enumsKeys, async (componentId)=>{
-                    const { target, path: p } = tpl.getTargetAndPath(names, componentId);
-                    result[`${key}__${componentId}`] = await exists(path.join(Sonamu.appRootPath, target, p));
-                });
-                return result;
-            }
-            const { target, path: p } = tpl.getTargetAndPath(names);
-            const { targets } = Sonamu.config.sync;
-            if (target.includes(":target")) {
-                await mapAsync(targets, async (t)=>{
-                    result[`${key}__${t}`] = await exists(path.join(Sonamu.appRootPath, target.replace(":target", t), p));
-                });
-            } else {
-                result[key] = await exists(path.join(Sonamu.appRootPath, target, p));
-            }
-            return result;
-        }, {});
-    }
-    /**
-   * 하위호환용 프록시 메소드입니다.
-   */ async createEntity(form) {
-        return await createEntity(form);
-    }
-    /**
-   * 하위호환용 프록시 메소드입니다.
-   */ async delEntity(entityId) {
-        return await delEntity(entityId);
-    }
-    /**
-   * 하위호환용 프록시 메소드입니다.
-   */ async generateTemplate(key, templateOptions, _generateOptions) {
-        return await generateTemplate(key, templateOptions, _generateOptions);
-    }
-    /**
-   * 하위호환용 프록시 메소드입니다.
-   */ async renderTemplate(key, templateOptions) {
-        return await renderTemplate(key, templateOptions);
-    }
-    /**
-   * 하위호환용 프록시 메소드입니다.
-   */ 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 {
-                // web/app의 경우 locale 파일들을 api에서 복사
-                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`));
-        }
-    }
-}
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import { hot } from \"@sonamu-kit/hmr-hook\";\nimport assert from \"assert\";\nimport chalk from \"chalk\";\nimport { EventEmitter } from \"events\";\nimport { mkdir, readFile, writeFile } from \"fs/promises\";\nimport inflection from \"inflection\";\nimport { minimatch } from \"minimatch\";\nimport path from \"path\";\nimport { group, unique } from \"radashi\";\nimport type { z } from \"zod\";\nimport type { WorkflowMetadata } from \"..\";\nimport { registeredApis } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager, type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport type { GenerateOptions, PathAndCode } from \"../types/types\";\nimport { TemplateKey, 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 {\n  checksumPatternGroup,\n  type FileType,\n  getChecksumPatternGroupInAbsolutePath,\n} from \"./file-patterns\";\nimport {\n  type LoadedApis,\n  type LoadedModels,\n  type LoadedTypes,\n  loadApis,\n  loadModels,\n  loadTypes,\n  loadWorkflows,\n} 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\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      if (modelPath.endsWith(\".frame.ts\")) {\n        const [, frameName] = modelPath.match(/.+\\/(.+)\\.frame\\.ts$/) ?? [];\n        assert(frameName);\n        // frameName을 PascalCase로 변환 (dashboard -> Dashboard)\n        const frameId = inflection.camelize(frameName);\n        return {\n          namesRecord: EntityManager.getNamesFromId(frameId),\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<Readonly<Record<string, string | number>>>;\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"],"names":["hot","assert","chalk","EventEmitter","mkdir","readFile","writeFile","inflection","minimatch","path","group","unique","registeredApis","Sonamu","EntityManager","AlreadyProcessedException","Naite","TemplateManager","TemplateKey","mapAsync","reduceAsync","centerText","isTest","copyFileWithReplaceCoreToShared","exists","runWithGracefulShutdown","findChangedFilesUsingChecksums","renewChecksums","generateTemplate","renderTemplate","createEntity","delEntity","checksumPatternGroup","getChecksumPatternGroupInAbsolutePath","loadApis","loadModels","loadTypes","loadWorkflows","SyncerActions","Syncer","apis","types","models","workflows","Map","eventEmitter","sync","targets","config","copySharedToTargets","changedFiles","length","console","log","black","bgGreen","overwrite","e","error","doSyncActions","whenThisHappens","waitForUpTo","syncFromWatcher","event","diffFilePath","includes","bold","yellow","invalidateFile","autoloadSSRRoutes","emit","invalidatedPaths","invalidatedPath","removedApis","removeInvalidatedRegisteredApis","blue","relative","apiRootPath","gray","red","test","devRunner","enabled","devVitestManager","invalidateFiles","dim","isInCheckPatternGroup","Object","values","some","pattern","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","endsWith","entityId","getEntityIdFromPath","toRemove","filter","api","modelName","idx","indexOf","splice","dictUtilsPath","join","dirname","replace","dictUtilsCode","convertMap","baseUrl","server","listen","host","port","dictUtils","target","srcPath","appRootPath","Error","fullText","convertedText","entries","reduce","acc","key","value","destPath","recursive","warn","synchronize","ssrConfigPath","clearSSRRoutes","globAsync","importMembers","runtimePath","files","file","diffFilePaths","diffGroups","calculateDiffGroups","diffTypes","keys","handleTruthSourceChanges","handleSyncableFileChanges","handleImplementationChanges","actionSyncConfig","syncSD","diffFiles","fileTypes","filePath","srcIndex","relativePath","slice","fileType","t","reload","entityPath","entity","at","undefined","get","typeFilePath","names","fs","parentId","actionGenerateSchemas","generated","push","tsPaths","functions","actionSyncFilesToTargets","mergedGroup","model","frame","params","map","modelPath","namesRecord","getNamesFromId","frameName","match","frameId","camelize","actionGenerateServices","actionGenerateHttps","actionGenerateSsr","checkExistsGenCode","templateKey","enumId","genPath","getTargetAndPath","subPath","fullPath","isExists","checkExists","enums","options","enumsKeys","name","constant","result","tpl","startsWith","componentId","p","form","templateOptions","_generateOptions","i18nConfig","i18n","targetList","apiI18nDir","dir","syncLocaleFiles","supportedLocales","locales","targetI18nDir","locale","sourceFile","targetFile","syncHeader","cyan"],"mappings":"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"}
+//#region src/syncer/syncer.ts
+var Syncer;
+var init_syncer = __esmMin((() => {
+	init_decorators();
+	init_sonamu();
+	init_entity_manager();
+	init_so_exceptions();
+	init_naite();
+	init_template_manager();
+	init_types();
+	init_async_utils();
+	init_console_util();
+	init_controller();
+	init_fs_utils();
+	init_process_utils();
+	init_checksum();
+	init_code_generator();
+	init_entity_operations();
+	init_file_patterns();
+	init_module_loader();
+	init_syncer_actions();
+	Syncer = class {
+		apis = [];
+		types = {};
+		models = {};
+		workflows = new Map();
+		eventEmitter = new EventEmitter();
+		/**
+		* 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
+		* sonamu.shared.ts는 파일이 없을 때만 1회 생성하고, 이후에는 덮어쓰지 않습니다.
+		* @returns
+		*/
+		async sync() {
+			const { targets } = Sonamu.config.sync;
+			await this.copySharedToTargets(targets);
+			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 () => {
+				await this.doSyncActions(changedFiles);
+				await renewChecksums();
+			}, {
+				whenThisHappens: "SIGUSR2",
+				waitForUpTo: 2e4
+			});
+		}
+		/**
+		* Watcher가 감지한 파일 변경 사항에 대해 싱크를 진행합니다.
+		* 주어진 변경 파일들 중 체크섬 관리 대상인 것들만 가져다가 싱크를 진행합니다.
+		* 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.
+		* @param diffFilePath - 변경 파일들. 프로젝트 루트부터 "src/" 또는 "dist/"로 시작하는 상대 경로입니다. 예시: "src/application/user/user.model.ts"
+		*/
+		async syncFromWatcher(event, diffFilePath) {
+			if (event !== "change" && event !== "add" && event !== "unlink") {
+				return;
+			}
+			if (diffFilePath.includes("/src/ssr/")) {
+				console.log(chalk.bold.yellow("SSR config changed - reloading..."));
+				if (!isTest()) {
+					await hot.invalidateFile(diffFilePath, event);
+				}
+				await this.autoloadSSRRoutes();
+				this.eventEmitter.emit("onHMRCompleted");
+				return;
+			}
+			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}`));
+						}
+					}
+				}
+			}
+			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")) {
+				return [];
+			}
+			const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);
+			const toRemove = registeredApis.filter((api) => api.modelName === `${entityId}Model`);
+			for (const api of toRemove) {
+				const idx = registeredApis.indexOf(api);
+				if (idx !== -1) {
+					registeredApis.splice(idx, 1);
+				}
+			}
+			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();
+		}
+		async autoloadModels() {
+			this.models = await loadModels();
+		}
+		async autoloadApis() {
+			this.apis = await loadApis();
+		}
+		async autoloadWorkflows() {
+			this.workflows = await loadWorkflows();
+			await Sonamu.workflows.synchronize(this.workflows);
+		}
+		async autoloadSSRRoutes() {
+			const ssrConfigPath = path.join(Sonamu.apiRootPath, "src/ssr");
+			const { clearSSRRoutes } = await import("../ssr/index.js");
+			clearSSRRoutes();
+			if (!await exists(ssrConfigPath)) {
+				return;
+			}
+			const { globAsync } = await import("../utils/async-utils.js");
+			const { importMembers } = await import("../utils/esm-utils.js");
+			const { runtimePath } = await import("../utils/path-utils.js");
+			const files = await globAsync(path.join(ssrConfigPath, runtimePath("**/*.ts")));
+			for (const file of files) {
+				try {
+					await importMembers(file);
+				} catch (e) {
+					console.error(`Failed to load SSR route: ${file}`, e);
+				}
+			}
+		}
+		/**
+		* 실제 싱크를 수행하는 본체입니다.
+		* 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.
+		* @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);
+			}
+			if (diffTypes.includes("types") || diffTypes.includes("functions") || diffTypes.includes("generated")) {
+				await this.handleSyncableFileChanges(diffGroups);
+			}
+			if (diffTypes.includes("model") || diffTypes.includes("frame")) {
+				await this.handleImplementationChanges(diffGroups);
+			}
+			if (diffTypes.includes("config")) {
+				await actionSyncConfig();
+			}
+			if (diffTypes.includes("workflow")) {
+				await this.autoloadWorkflows();
+			}
+			if (diffTypes.includes("i18n") || diffTypes.includes("entity") || diffTypes.includes("config")) {
+				await this.syncSD();
+			}
+			return { diffTypes };
+		}
+		calculateDiffGroups(diffFiles) {
+			const fileTypes = Object.keys(checksumPatternGroup);
+			return group(diffFiles, (filePath) => {
+				const srcIndex = filePath.indexOf("/src/");
+				if (srcIndex === -1) return "unknown";
+				const relativePath = filePath.slice(srcIndex + 1);
+				for (const fileType of fileTypes) {
+					if (minimatch(relativePath, checksumPatternGroup[fileType])) {
+						return fileType;
+					}
+				}
+				return "unknown";
+			});
+		}
+		async handleTruthSourceChanges(diffGroups, diffTypes) {
+			Naite.t("handleTruthSourceChanges", {
+				diffGroups,
+				diffTypes
+			});
+			await EntityManager.reload();
+			const entityPath = diffGroups.entity?.at(0);
+			if (entityPath !== undefined) {
+				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 === undefined && !await exists(typeFilePath)) {
+					await generateTemplate("init_types", { entityId });
+				}
+			}
+			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 [];
+		}
+		async handleImplementationChanges(diffGroups) {
+			Naite.t("handleImplementationChanges", { diffGroups });
+			const mergedGroup = [...diffGroups.model ?? [], ...diffGroups.frame ?? []];
+			await this.autoloadModels();
+			await this.autoloadTypes();
+			await this.autoloadApis();
+			const params = mergedGroup.map((modelPath) => {
+				if (modelPath.endsWith(".model.ts")) {
+					const entityId = EntityManager.getEntityIdFromPath(modelPath);
+					assert(entityId);
+					return { namesRecord: EntityManager.getNamesFromId(entityId) };
+				}
+				if (modelPath.endsWith(".frame.ts")) {
+					const [, frameName] = modelPath.match(/.+\/(.+)\.frame\.ts$/) ?? [];
+					assert(frameName);
+					const frameId = inflection.camelize(frameName);
+					return { namesRecord: EntityManager.getNamesFromId(frameId) };
+				}
+				throw new Error("not reachable");
+			});
+			await actionGenerateServices(params);
+			await actionGenerateHttps();
+			await actionGenerateSsr();
+		}
+		/**
+		* 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.
+		* @param entityId 엔티티 ID
+		* @param templateKey 템플릿 키
+		* @param enumId 열거형 ID
+		* @returns 생성된 코드가 존재하는지 여부
+		*/
+		async checkExistsGenCode(entityId, templateKey, enumId) {
+			const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(EntityManager.getNamesFromId(entityId), enumId);
+			const subPath = path.join(target, genPath);
+			const fullPath = path.join(Sonamu.appRootPath, subPath);
+			return {
+				subPath,
+				fullPath,
+				isExists: await exists(fullPath)
+			};
+		}
+		/**
+		* 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.
+		* @param entityId 엔티티 ID
+		* @param enums 열거형 레이블
+		* @returns 생성된 코드가 존재하는지 여부
+		*/
+		async checkExists(entityId, enums) {
+			const keys = TemplateKey.options;
+			const names = EntityManager.getNamesFromId(entityId);
+			const enumsKeys = Object.keys(enums).filter((name) => name !== names.constant);
+			return await reduceAsync(keys, async (result, key) => {
+				const tpl = TemplateManager.get(key);
+				if (key.startsWith("view_enums")) {
+					await mapAsync(enumsKeys, async (componentId) => {
+						const { target: target$1, path: p$1 } = tpl.getTargetAndPath(names, componentId);
+						result[`${key}__${componentId}`] = await exists(path.join(Sonamu.appRootPath, target$1, p$1));
+					});
+					return result;
+				}
+				const { target, path: p } = tpl.getTargetAndPath(names);
+				const { targets } = Sonamu.config.sync;
+				if (target.includes(":target")) {
+					await mapAsync(targets, async (t) => {
+						result[`${key}__${t}`] = await exists(path.join(Sonamu.appRootPath, target.replace(":target", t), p));
+					});
+				} else {
+					result[key] = await exists(path.join(Sonamu.appRootPath, target, p));
+				}
+				return result;
+			}, {});
+		}
+		/**
+		* 하위호환용 프록시 메소드입니다.
+		*/
+		async createEntity(form) {
+			return await createEntity(form);
+		}
+		/**
+		* 하위호환용 프록시 메소드입니다.
+		*/
+		async delEntity(entityId) {
+			return await delEntity(entityId);
+		}
+		/**
+		* 하위호환용 프록시 메소드입니다.
+		*/
+		async generateTemplate(key, templateOptions, _generateOptions) {
+			return await generateTemplate(key, templateOptions, _generateOptions);
+		}
+		/**
+		* 하위호환용 프록시 메소드입니다.
+		*/
+		async renderTemplate(key, templateOptions) {
+			return await renderTemplate(key, templateOptions);
+		}
+		/**
+		* 하위호환용 프록시 메소드입니다.
+		*/
+		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 inflection from \"inflection\";\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\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      if (modelPath.endsWith(\".frame.ts\")) {\n        const [, frameName] = modelPath.match(/.+\\/(.+)\\.frame\\.ts$/) ?? [];\n        assert(frameName);\n        // frameName을 PascalCase로 변환 (dashboard -> Dashboard)\n        const frameId = inflection.camelize(frameName);\n        return {\n          namesRecord: EntityManager.getNamesFromId(frameId),\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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"}