sonamu 0.7.53 → 0.8.0

package/dist/syncer/syncer.js

@@ -19,7 +19,7 @@ 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 { areFilesSame, findChangedFilesUsingChecksums, renewChecksums } from "./checksum.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";
@@ -33,11 +33,11 @@ export class Syncer {
     eventEmitter = new EventEmitter();
     /**
    * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
-   * 다만 sonamu.shared.ts는 체크섬 비교 없이 무조건 싱크(복사)합니다.
+   * sonamu.shared.ts는 파일이 없을 때만 1회 생성하고, 이후에는 덮어쓰지 않습니다.
    * @returns
    */ async sync() {
         const { targets } = Sonamu.config.sync;
-        // sonamu.shared.ts는 무조건 싱크(복사)합니다.
+        // sonamu.shared.ts는 파일이 없을 때만 1회 생성합니다.
         await this.copySharedToTargets(targets);
         // 그 다음부터는 변경된 파일을 찾아서 동기화 작업을 실행합니다.
         const changedFiles = await findChangedFilesUsingChecksums();
@@ -174,11 +174,12 @@ export class Syncer {
                 });
                 console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);
             }
-            if (await areFilesSame({
-                data: convertedText
-            }, {
-                path: destPath
-            })) {
+            // 파일이 이미 존재하면 건너뜁니다.
+            // sonamu.shared.ts는 프로젝트에서 자유롭게 커스터마이징할 수 있어야 하므로,
+            // 최초 1회만 생성하고 이후에는 덮어쓰지 않습니다.
+            // 템플릿 내용($[[dictUtils]] 등)이 변경되었을 때 반영이 필요하면,
+            // 해당 파일을 삭제한 뒤 `pnpm sonamu sync`로 재생성하면 됩니다.
+            if (await exists(destPath)) {
                 continue;
             }
             await writeFile(destPath, convertedText);
@@ -469,10 +470,16 @@ export class Syncer {
         for (const locale of locales){
             const sourceFile = path.join(apiI18nDir, `${locale}.ts`);
             const targetFile = path.join(targetI18nDir, `${locale}.ts`);
-            await copyFileWithReplaceCoreToShared(sourceFile, targetFile);
+            const syncHeader = [
+                "/**",
+                " * @generated",
+                " * API에서 동기화된 파일입니다. 직접 수정하지 마세요.",
+                " */"
+            ].join("\n");
+            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 { areFilesSame, 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는 체크섬 비교 없이 무조건 싱크(복사)합니다.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    const { targets } = Sonamu.config.sync;\n\n    // sonamu.shared.ts는 무조건 싱크(복사)합니다.\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    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      registeredApis.splice(registeredApis.indexOf(api), 1);\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      if (await areFilesSame({ data: convertedText }, { path: 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);\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      await copyFileWithReplaceCoreToShared(sourceFile, targetFile);\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","areFilesSame","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","isInCheckPatternGroup","Object","values","some","pattern","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","endsWith","entityId","getEntityIdFromPath","toRemove","filter","api","modelName","splice","indexOf","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","data","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","cyan"],"mappings":"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"}
+//# 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    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      registeredApis.splice(registeredApis.indexOf(api), 1);\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);\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","isInCheckPatternGroup","Object","values","some","pattern","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","endsWith","entityId","getEntityIdFromPath","toRemove","filter","api","modelName","splice","indexOf","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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"}

package/dist/tasks/workflow-manager.d.ts

@@ -1,5 +1,6 @@
 import { type Logger } from "@logtape/logtape";
-import type { RunnableWorkflow, SchemaInput, SchemaOutput, StandardSchemaV1, WorkflowRunHandle, WorkflowSpec } from "@sonamu-kit/tasks/internal";
+import { BackendPostgres } from "@sonamu-kit/tasks";
+import { type RunnableWorkflow, type SchemaInput, type SchemaOutput, type StandardSchemaV1, type WorkflowRunHandle, type WorkflowSpec } from "@sonamu-kit/tasks/internal";
 import type { Knex } from "knex";
 import type { WorkflowMetadata } from "./decorator";
 import { StepWrapper } from "./step-wrapper";
@@ -22,6 +23,17 @@ export type WorkflowCreateOptions<Input, Output, TSchema extends StandardSchemaV
 export declare class WorkflowManager {
     #private;
     constructor(dbConf: Knex.Config, runMigrations?: boolean);
+    get backend(): BackendPostgres;
+    get workflowDefinitions(): {
+        id: string;
+        name: string;
+        version: string | null;
+        schedules: {
+            name: string;
+            expression: string;
+        }[];
+        retryPolicy: import("@sonamu-kit/tasks/internal").SerializableRetryPolicy | undefined;
+    }[];
     /**
      * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.
      */

package/dist/tasks/workflow-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-manager.d.ts","sourceRoot":"","sources":["../../src/tasks/workflow-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"workflow-manager.d.ts","sourceRoot":"","sources":["../../src/tasks/workflow-manager.ts"],"names":[],"mappings":"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"}

package/dist/tasks/workflow-manager.js

@@ -1,5 +1,6 @@
 import { getLogger } from "@logtape/logtape";
 import { BackendPostgres, OpenWorkflow } from "@sonamu-kit/tasks";
+import { serializeRetryPolicy } from "@sonamu-kit/tasks/internal";
 import assert from "assert";
 import { schedule as cronSchedule } from "node-cron";
 import { Sonamu } from "../api/sonamu.js";
@@ -31,6 +32,22 @@ export class WorkflowManager {
         this.#workflowsMap = new Map();
         this.#scheduledTasks = new Map();
     }
+    // Sonamu UI API에서 워크플로우 실행 목록 조회, 취소 등에 사용합니다.
+    get backend() {
+        return this.#backend;
+    }
+    get workflowDefinitions() {
+        return Array.from(this.#workflowsMap.values()).flat().map((wf)=>({
+                id: wf.id,
+                name: wf.name,
+                version: wf.version,
+                schedules: wf.schedules.map((s)=>({
+                        name: s.name,
+                        expression: s.expression
+                    })),
+                retryPolicy: wf.retryPolicy ? serializeRetryPolicy(wf.retryPolicy) : undefined
+            }));
+    }
     /**
    * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.
    */ async synchronize(workflowMap) {
@@ -205,4 +222,4 @@ export class WorkflowManager {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/tasks/workflow-manager.ts"],"sourcesContent":["import { getLogger, type Logger } from \"@logtape/logtape\";\nimport { BackendPostgres, OpenWorkflow, type Worker } from \"@sonamu-kit/tasks\";\nimport type {\n  RunnableWorkflow,\n  SchemaInput,\n  SchemaOutput,\n  StandardSchemaV1,\n  StepApi,\n  WorkflowRunHandle,\n  WorkflowSpec,\n} from \"@sonamu-kit/tasks/internal\";\nimport assert from \"assert\";\nimport type { Knex } from \"knex\";\nimport { schedule as cronSchedule, type ScheduledTask } from \"node-cron\";\nimport type { ZodObject } from \"zod\";\nimport type { Context } from \"../api/context\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { convertDomainToCategory } from \"../logger/category\";\nimport { Naite } from \"../naite/naite\";\nimport { createMockSSEFactory } from \"../stream/sse\";\nimport type { Executable } from \"../types/types\";\nimport type { WorkflowMetadata } from \"./decorator\";\nimport { StepWrapper } from \"./step-wrapper\";\n\nexport interface WorkflowOptions {\n  // worker에서 동시 실행할 태스크 수, 기본은 CPU 코어 수 - 1개\n  concurrency?: number;\n\n  // worker에서 사용할 pub/sub 여부, 기본은 true\n  usePubSub?: boolean;\n\n  // pub/sub으로 태스크를 수신했을 때 워크플로우 실행까지 지연 시간, 기본은 500ms\n  listenDelay?: number;\n}\n\n// Workflow 함수의 타입, @sonamu-kit/tasks와 다른 점은 step을 한번 감싼 형태.\nexport type WorkflowFunction<Input, Output> = (\n  params: Readonly<{\n    logger: Logger;\n    input: Input;\n    step: StepWrapper;\n    version: string | null;\n  }>,\n) => Promise<Output> | Output;\n\n// Workflow를 등록할 때를 위한 타입\nexport type WorkflowCreateOptions<\n  Input,\n  Output,\n  TSchema extends StandardSchemaV1 | undefined = undefined,\n> = Omit<\n  WorkflowSpec<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>,\n  \"version\"\n> & {\n  id: string;\n  version: string | null;\n  function: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>;\n};\n\nexport class WorkflowManager {\n  // backend 인스턴스\n  readonly #backend: BackendPostgres;\n\n  // OpenWorkflow 인스턴스\n  readonly #ow: OpenWorkflow;\n\n  // Worker 인스턴스 (없을 수 있으며, 이 때는 분산된 서버 환경에서 DB에 publish만 한다고 가정함)\n  #worker: Worker | null;\n\n  // 파일 경로 -> 파일에 정의된 워크플로우 메타데이터 목록\n  #workflowsMap: Map<string, WorkflowMetadata[]>;\n\n  // Task 이름 -> Task 정보 및 Input 값, Workflow ID\n  #scheduledTasks: Map<\n    string,\n    {\n      task: ScheduledTask;\n      inputFn: Executable<SchemaInput<unknown, unknown>>;\n      workflowId: string;\n    }\n  >;\n\n  // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.\n  constructor(dbConf: Knex.Config, runMigrations: boolean = true) {\n    const backend = new BackendPostgres(dbConf, { runMigrations });\n\n    this.#backend = backend;\n    this.#ow = new OpenWorkflow({ backend });\n    this.#worker = null;\n\n    this.#workflowsMap = new Map();\n    this.#scheduledTasks = new Map();\n  }\n\n  /**\n   * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.\n   */\n  async synchronize(workflowMap: Map<string, WorkflowMetadata[]>) {\n    // 1. 삭제된 파일은 일괄 삭제\n    await Promise.allSettled(\n      Array.from(this.#workflowsMap.entries())\n        .filter(([key]) => !workflowMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            return Promise.allSettled([\n              ...workflow.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n              this.unregisterWorkflow(workflow),\n            ]);\n          }),\n        ),\n    );\n\n    // 2. 새로 추가된 파일은 일괄 등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => !this.#workflowsMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            this.registerWorkflow({\n              id: workflow.id,\n              name: workflow.name,\n              version: workflow.version ?? null,\n              schema: workflow.schema,\n              function: workflow.fn,\n              retryPolicy: workflow.retryPolicy,\n            });\n\n            return Promise.allSettled(\n              workflow.schedules.map((schedule) => this.scheduleTask(workflow, schedule)),\n            );\n          }),\n        ),\n    );\n\n    // 3. 기존과 다른 것을 diff친 다음, 삭제 후 재등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => this.#workflowsMap.has(key))\n        .map<[string, [WorkflowMetadata[], WorkflowMetadata[]]]>(([key, newWorkflows]) => {\n          const previousWorkflows = this.#workflowsMap.get(key);\n          assert(previousWorkflows, \"previous workflows not found\");\n          return [key, [previousWorkflows, newWorkflows]];\n        })\n        .map(async ([_, [previousWorkflows, newWorkflows]]) => {\n          // 기존 것들을 삭제부터 해야함.\n          await Promise.allSettled(\n            previousWorkflows\n              .filter((prevItem) => !newWorkflows.some((newItem) => newItem.id === prevItem.id))\n              .map((prevItem) => {\n                return Promise.allSettled([\n                  ...prevItem.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n                  this.unregisterWorkflow(prevItem),\n                ]);\n              }),\n          );\n\n          // 새로 추가된 것들을 등록\n          await Promise.allSettled(\n            newWorkflows\n              .filter(\n                (newItem) => !previousWorkflows.some((prevItem) => prevItem.id === newItem.id),\n              )\n              .map(async (newItem) => {\n                this.registerWorkflow({\n                  id: newItem.id,\n                  name: newItem.name,\n                  version: newItem.version ?? null,\n                  schema: newItem.schema,\n                  function: newItem.fn,\n                  retryPolicy: newItem.retryPolicy,\n                });\n\n                return Promise.allSettled(\n                  newItem.schedules.map((schedule) => this.scheduleTask(newItem, schedule)),\n                );\n              }),\n          );\n        }),\n    );\n\n    this.#workflowsMap = workflowMap;\n  }\n\n  // 워크플로우를 실행\n  run<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: Omit<WorkflowCreateOptions<Input, Output, TSchema>, \"function\" | \"schema\" | \"id\">,\n    input: SchemaInput<TSchema, Input>,\n  ): Promise<WorkflowRunHandle<Output>> {\n    return this.#ow.runWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n      },\n      input,\n    );\n  }\n\n  // cron task를 등록\n  async scheduleTask(\n    workflow: Pick<WorkflowMetadata, \"id\" | \"name\" | \"version\">,\n    schedule: WorkflowMetadata[\"schedules\"][number],\n  ) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const task = cronSchedule(\n      schedule.expression,\n      (async (\n        { name, version }: Pick<WorkflowMetadata, \"name\" | \"version\">,\n        { input }: WorkflowMetadata[\"schedules\"][number],\n      ) => {\n        const inputData = await (typeof input === \"function\"\n          ? Promise.resolve(input())\n          : Promise.resolve(input));\n\n        return this.run({ name, version: version ?? null }, inputData);\n      }).bind(this, workflow, schedule),\n      {\n        name: schedule.name,\n        timezone: Sonamu.config.api.timezone,\n        noOverlap: false,\n      },\n    );\n\n    this.#scheduledTasks.set(schedule.name, {\n      task,\n      inputFn: schedule.input,\n      workflowId: workflow.id,\n    });\n    await task.start();\n  }\n\n  // cron task를 중지\n  async unscheduleTask(name: string) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const taskItem = this.#scheduledTasks.get(name);\n    if (!taskItem) {\n      console.error(\"scheduled task not found\", name);\n      return;\n    }\n\n    this.#scheduledTasks.delete(name);\n    await taskItem.task.stop();\n    await taskItem.task.destroy();\n  }\n\n  // 워크플로우를 등록, 관련된 스케줄은 별도로 등록해야 함.\n  registerWorkflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: WorkflowCreateOptions<Input, Output, TSchema>,\n  ): RunnableWorkflow<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>> {\n    const fn = async (\n      params: Readonly<{\n        input: SchemaOutput<TSchema, Input>;\n        step: StepApi;\n        version: string | null;\n      }>,\n    ) => {\n      const baseContext = {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        naiteStore: Naite.createStore(),\n        user: null,\n        passport: {\n          login: async () => {},\n          logout: () => {},\n        },\n      } as unknown as Context;\n\n      const contextProvider = Sonamu.config.tasks?.contextProvider;\n      const context: Context = contextProvider\n        ? await Promise.resolve(contextProvider(baseContext))\n        : baseContext;\n\n      const step = new StepWrapper(params.step);\n      return Sonamu.asyncLocalStorage.run({ context }, () =>\n        options.function({\n          input: params.input,\n          step,\n          version: params.version,\n          logger: getLogger(convertDomainToCategory(options.name, \"workflow\")),\n        }),\n      );\n    };\n\n    const workflow = this.#ow.defineWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n        schema: options.schema,\n        retryPolicy: options.retryPolicy,\n      },\n      fn,\n    );\n    return workflow;\n  }\n\n  // 워크플로우를 등록 해제, 관련된 스케줄은 별도로 해제해야 함.\n  async unregisterWorkflow(workflow: Pick<WorkflowMetadata, \"name\" | \"version\" | \"id\">) {\n    this.#ow.unregisterWorkflow(workflow.name, workflow.version ?? null);\n  }\n\n  // Worker를 설정 후 시작\n  setupWorker(options: WorkflowOptions) {\n    this.#worker = this.#ow.newWorker(options);\n  }\n\n  // Worker가 있으면 Worker까지 초기화, 아니면 백엔드만 초기화\n  async startWorker() {\n    await this.#backend.initialize();\n    await this.#worker?.start();\n  }\n\n  // Worker를 중지\n  async stopWorker() {\n    await this.#worker?.stop();\n  }\n\n  // cron task들을 모두 중지\n  async stopSchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.stop())),\n    );\n  }\n\n  // cron task들을 모두 정리\n  async destroySchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.destroy())),\n    );\n    this.#scheduledTasks.clear();\n  }\n\n  async destroy() {\n    await this.stopSchedules();\n    await this.stopWorker();\n    await this.destroySchedules();\n    await this.#backend.stop();\n  }\n\n  [Symbol.asyncDispose]() {\n    return this.destroy();\n  }\n}\n"],"names":["getLogger","BackendPostgres","OpenWorkflow","assert","schedule","cronSchedule","Sonamu","convertDomainToCategory","Naite","createMockSSEFactory","StepWrapper","WorkflowManager","dbConf","runMigrations","backend","Map","synchronize","workflowMap","Promise","allSettled","Array","from","entries","filter","key","has","flatMap","_","workflows","map","workflow","schedules","unscheduleTask","name","unregisterWorkflow","registerWorkflow","id","version","schema","function","fn","retryPolicy","scheduleTask","newWorkflows","previousWorkflows","get","prevItem","some","newItem","run","options","input","runWorkflow","undefined","task","expression","inputData","resolve","bind","timezone","config","api","noOverlap","set","inputFn","workflowId","start","taskItem","console","error","delete","stop","destroy","params","baseContext","request","reply","headers","createSSE","naiteStore","createStore","user","passport","login","logout","contextProvider","tasks","context","step","asyncLocalStorage","logger","defineWorkflow","setupWorker","newWorker","startWorker","initialize","stopWorker","stopSchedules","values","destroySchedules","clear","Symbol","asyncDispose"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/tasks/workflow-manager.ts"],"sourcesContent":["import { getLogger, type Logger } from \"@logtape/logtape\";\nimport { BackendPostgres, OpenWorkflow, type Worker } from \"@sonamu-kit/tasks\";\nimport {\n  type RunnableWorkflow,\n  type SchemaInput,\n  type SchemaOutput,\n  type StandardSchemaV1,\n  type StepApi,\n  serializeRetryPolicy,\n  type WorkflowRunHandle,\n  type WorkflowSpec,\n} from \"@sonamu-kit/tasks/internal\";\nimport assert from \"assert\";\nimport type { Knex } from \"knex\";\nimport { schedule as cronSchedule, type ScheduledTask } from \"node-cron\";\nimport type { ZodObject } from \"zod\";\nimport type { Context } from \"../api/context\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { convertDomainToCategory } from \"../logger/category\";\nimport { Naite } from \"../naite/naite\";\nimport { createMockSSEFactory } from \"../stream/sse\";\nimport type { Executable } from \"../types/types\";\nimport type { WorkflowMetadata } from \"./decorator\";\nimport { StepWrapper } from \"./step-wrapper\";\n\nexport interface WorkflowOptions {\n  // worker에서 동시 실행할 태스크 수, 기본은 CPU 코어 수 - 1개\n  concurrency?: number;\n\n  // worker에서 사용할 pub/sub 여부, 기본은 true\n  usePubSub?: boolean;\n\n  // pub/sub으로 태스크를 수신했을 때 워크플로우 실행까지 지연 시간, 기본은 500ms\n  listenDelay?: number;\n}\n\n// Workflow 함수의 타입, @sonamu-kit/tasks와 다른 점은 step을 한번 감싼 형태.\nexport type WorkflowFunction<Input, Output> = (\n  params: Readonly<{\n    logger: Logger;\n    input: Input;\n    step: StepWrapper;\n    version: string | null;\n  }>,\n) => Promise<Output> | Output;\n\n// Workflow를 등록할 때를 위한 타입\nexport type WorkflowCreateOptions<\n  Input,\n  Output,\n  TSchema extends StandardSchemaV1 | undefined = undefined,\n> = Omit<\n  WorkflowSpec<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>,\n  \"version\"\n> & {\n  id: string;\n  version: string | null;\n  function: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>;\n};\n\nexport class WorkflowManager {\n  // backend 인스턴스\n  readonly #backend: BackendPostgres;\n\n  // OpenWorkflow 인스턴스\n  readonly #ow: OpenWorkflow;\n\n  // Worker 인스턴스 (없을 수 있으며, 이 때는 분산된 서버 환경에서 DB에 publish만 한다고 가정함)\n  #worker: Worker | null;\n\n  // 파일 경로 -> 파일에 정의된 워크플로우 메타데이터 목록\n  #workflowsMap: Map<string, WorkflowMetadata[]>;\n\n  // Task 이름 -> Task 정보 및 Input 값, Workflow ID\n  #scheduledTasks: Map<\n    string,\n    {\n      task: ScheduledTask;\n      inputFn: Executable<SchemaInput<unknown, unknown>>;\n      workflowId: string;\n    }\n  >;\n\n  // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.\n  constructor(dbConf: Knex.Config, runMigrations: boolean = true) {\n    const backend = new BackendPostgres(dbConf, { runMigrations });\n\n    this.#backend = backend;\n    this.#ow = new OpenWorkflow({ backend });\n    this.#worker = null;\n\n    this.#workflowsMap = new Map();\n    this.#scheduledTasks = new Map();\n  }\n\n  // Sonamu UI API에서 워크플로우 실행 목록 조회, 취소 등에 사용합니다.\n  get backend(): BackendPostgres {\n    return this.#backend;\n  }\n\n  get workflowDefinitions() {\n    return Array.from(this.#workflowsMap.values())\n      .flat()\n      .map((wf) => ({\n        id: wf.id,\n        name: wf.name,\n        version: wf.version,\n        schedules: wf.schedules.map((s) => ({\n          name: s.name,\n          expression: s.expression,\n        })),\n        retryPolicy: wf.retryPolicy ? serializeRetryPolicy(wf.retryPolicy) : undefined,\n      }));\n  }\n\n  /**\n   * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.\n   */\n  async synchronize(workflowMap: Map<string, WorkflowMetadata[]>) {\n    // 1. 삭제된 파일은 일괄 삭제\n    await Promise.allSettled(\n      Array.from(this.#workflowsMap.entries())\n        .filter(([key]) => !workflowMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            return Promise.allSettled([\n              ...workflow.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n              this.unregisterWorkflow(workflow),\n            ]);\n          }),\n        ),\n    );\n\n    // 2. 새로 추가된 파일은 일괄 등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => !this.#workflowsMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            this.registerWorkflow({\n              id: workflow.id,\n              name: workflow.name,\n              version: workflow.version ?? null,\n              schema: workflow.schema,\n              function: workflow.fn,\n              retryPolicy: workflow.retryPolicy,\n            });\n\n            return Promise.allSettled(\n              workflow.schedules.map((schedule) => this.scheduleTask(workflow, schedule)),\n            );\n          }),\n        ),\n    );\n\n    // 3. 기존과 다른 것을 diff친 다음, 삭제 후 재등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => this.#workflowsMap.has(key))\n        .map<[string, [WorkflowMetadata[], WorkflowMetadata[]]]>(([key, newWorkflows]) => {\n          const previousWorkflows = this.#workflowsMap.get(key);\n          assert(previousWorkflows, \"previous workflows not found\");\n          return [key, [previousWorkflows, newWorkflows]];\n        })\n        .map(async ([_, [previousWorkflows, newWorkflows]]) => {\n          // 기존 것들을 삭제부터 해야함.\n          await Promise.allSettled(\n            previousWorkflows\n              .filter((prevItem) => !newWorkflows.some((newItem) => newItem.id === prevItem.id))\n              .map((prevItem) => {\n                return Promise.allSettled([\n                  ...prevItem.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n                  this.unregisterWorkflow(prevItem),\n                ]);\n              }),\n          );\n\n          // 새로 추가된 것들을 등록\n          await Promise.allSettled(\n            newWorkflows\n              .filter(\n                (newItem) => !previousWorkflows.some((prevItem) => prevItem.id === newItem.id),\n              )\n              .map(async (newItem) => {\n                this.registerWorkflow({\n                  id: newItem.id,\n                  name: newItem.name,\n                  version: newItem.version ?? null,\n                  schema: newItem.schema,\n                  function: newItem.fn,\n                  retryPolicy: newItem.retryPolicy,\n                });\n\n                return Promise.allSettled(\n                  newItem.schedules.map((schedule) => this.scheduleTask(newItem, schedule)),\n                );\n              }),\n          );\n        }),\n    );\n\n    this.#workflowsMap = workflowMap;\n  }\n\n  // 워크플로우를 실행\n  run<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: Omit<WorkflowCreateOptions<Input, Output, TSchema>, \"function\" | \"schema\" | \"id\">,\n    input: SchemaInput<TSchema, Input>,\n  ): Promise<WorkflowRunHandle<Output>> {\n    return this.#ow.runWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n      },\n      input,\n    );\n  }\n\n  // cron task를 등록\n  async scheduleTask(\n    workflow: Pick<WorkflowMetadata, \"id\" | \"name\" | \"version\">,\n    schedule: WorkflowMetadata[\"schedules\"][number],\n  ) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const task = cronSchedule(\n      schedule.expression,\n      (async (\n        { name, version }: Pick<WorkflowMetadata, \"name\" | \"version\">,\n        { input }: WorkflowMetadata[\"schedules\"][number],\n      ) => {\n        const inputData = await (typeof input === \"function\"\n          ? Promise.resolve(input())\n          : Promise.resolve(input));\n\n        return this.run({ name, version: version ?? null }, inputData);\n      }).bind(this, workflow, schedule),\n      {\n        name: schedule.name,\n        timezone: Sonamu.config.api.timezone,\n        noOverlap: false,\n      },\n    );\n\n    this.#scheduledTasks.set(schedule.name, {\n      task,\n      inputFn: schedule.input,\n      workflowId: workflow.id,\n    });\n    await task.start();\n  }\n\n  // cron task를 중지\n  async unscheduleTask(name: string) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const taskItem = this.#scheduledTasks.get(name);\n    if (!taskItem) {\n      console.error(\"scheduled task not found\", name);\n      return;\n    }\n\n    this.#scheduledTasks.delete(name);\n    await taskItem.task.stop();\n    await taskItem.task.destroy();\n  }\n\n  // 워크플로우를 등록, 관련된 스케줄은 별도로 등록해야 함.\n  registerWorkflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: WorkflowCreateOptions<Input, Output, TSchema>,\n  ): RunnableWorkflow<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>> {\n    const fn = async (\n      params: Readonly<{\n        input: SchemaOutput<TSchema, Input>;\n        step: StepApi;\n        version: string | null;\n      }>,\n    ) => {\n      const baseContext = {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        naiteStore: Naite.createStore(),\n        user: null,\n        passport: {\n          login: async () => {},\n          logout: () => {},\n        },\n      } as unknown as Context;\n\n      const contextProvider = Sonamu.config.tasks?.contextProvider;\n      const context: Context = contextProvider\n        ? await Promise.resolve(contextProvider(baseContext))\n        : baseContext;\n\n      const step = new StepWrapper(params.step);\n      return Sonamu.asyncLocalStorage.run({ context }, () =>\n        options.function({\n          input: params.input,\n          step,\n          version: params.version,\n          logger: getLogger(convertDomainToCategory(options.name, \"workflow\")),\n        }),\n      );\n    };\n\n    const workflow = this.#ow.defineWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n        schema: options.schema,\n        retryPolicy: options.retryPolicy,\n      },\n      fn,\n    );\n    return workflow;\n  }\n\n  // 워크플로우를 등록 해제, 관련된 스케줄은 별도로 해제해야 함.\n  async unregisterWorkflow(workflow: Pick<WorkflowMetadata, \"name\" | \"version\" | \"id\">) {\n    this.#ow.unregisterWorkflow(workflow.name, workflow.version ?? null);\n  }\n\n  // Worker를 설정 후 시작\n  setupWorker(options: WorkflowOptions) {\n    this.#worker = this.#ow.newWorker(options);\n  }\n\n  // Worker가 있으면 Worker까지 초기화, 아니면 백엔드만 초기화\n  async startWorker() {\n    await this.#backend.initialize();\n    await this.#worker?.start();\n  }\n\n  // Worker를 중지\n  async stopWorker() {\n    await this.#worker?.stop();\n  }\n\n  // cron task들을 모두 중지\n  async stopSchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.stop())),\n    );\n  }\n\n  // cron task들을 모두 정리\n  async destroySchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.destroy())),\n    );\n    this.#scheduledTasks.clear();\n  }\n\n  async destroy() {\n    await this.stopSchedules();\n    await this.stopWorker();\n    await this.destroySchedules();\n    await this.#backend.stop();\n  }\n\n  [Symbol.asyncDispose]() {\n    return this.destroy();\n  }\n}\n"],"names":["getLogger","BackendPostgres","OpenWorkflow","serializeRetryPolicy","assert","schedule","cronSchedule","Sonamu","convertDomainToCategory","Naite","createMockSSEFactory","StepWrapper","WorkflowManager","dbConf","runMigrations","backend","Map","workflowDefinitions","Array","from","values","flat","map","wf","id","name","version","schedules","s","expression","retryPolicy","undefined","synchronize","workflowMap","Promise","allSettled","entries","filter","key","has","flatMap","_","workflows","workflow","unscheduleTask","unregisterWorkflow","registerWorkflow","schema","function","fn","scheduleTask","newWorkflows","previousWorkflows","get","prevItem","some","newItem","run","options","input","runWorkflow","task","inputData","resolve","bind","timezone","config","api","noOverlap","set","inputFn","workflowId","start","taskItem","console","error","delete","stop","destroy","params","baseContext","request","reply","headers","createSSE","naiteStore","createStore","user","passport","login","logout","contextProvider","tasks","context","step","asyncLocalStorage","logger","defineWorkflow","setupWorker","newWorker","startWorker","initialize","stopWorker","stopSchedules","destroySchedules","clear","Symbol","asyncDispose"],"mappings":"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"}

package/dist/template/entity-converter.js

@@ -10,11 +10,11 @@ import { propToZodType, zodTypeToRenderingNode } from "./zod-converter.js";
  * object와 array의 경우 적절한 pick 필드를 자동으로 선택합니다.
  */ export async function getColumnsNode(entityId, subsetKey) {
     const entity = EntityManager.get(entityId);
-    const subset = entity.subsets[subsetKey];
-    if (subset === undefined) {
+    const subsetDef = entity.subsets[subsetKey];
+    if (subsetDef === undefined) {
         throw new ServiceUnavailableException(SD("sonamu.error.subsetNotFound")(subsetKey));
     }
-    const propNodes = entity.fieldExprsToPropNodes(subset);
+    const propNodes = entity.fieldExprsToPropNodes(subsetDef);
     const rootPropNode = {
         nodeType: "object",
         children: propNodes
@@ -106,4 +106,4 @@ import { propToZodType, zodTypeToRenderingNode } from "./zod-converter.js";
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/template/entity-converter.ts"],"sourcesContent":["import assert from \"assert\";\nimport z from \"zod\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { ServiceUnavailableException } from \"../exceptions/so-exceptions\";\nimport type { EntityPropNode, RenderingNode } from \"../types/types\";\nimport { propToZodType, zodTypeToRenderingNode } from \"./zod-converter\";\n\n/**\n * 엔티티의 특정 subset을 RenderingNode로 변환합니다.\n * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.\n * object와 array의 경우 적절한 pick 필드를 자동으로 선택합니다.\n */\nexport async function getColumnsNode(entityId: string, subsetKey: string): Promise<RenderingNode> {\n  const entity = EntityManager.get(entityId);\n  const subset = entity.subsets[subsetKey];\n  if (subset === undefined) {\n    throw new ServiceUnavailableException(SD(\"sonamu.error.subsetNotFound\")(subsetKey));\n  }\n  const propNodes = entity.fieldExprsToPropNodes(subset);\n  const rootPropNode: EntityPropNode = {\n    nodeType: \"object\",\n    children: propNodes,\n  };\n\n  // biome-ignore lint/suspicious/noExplicitAny: zod 스키마를 로드할 때 사용하는 타입\n  const columnsZodType = (await propNodeToZodType(rootPropNode)) as z.ZodObject<any>;\n\n  const columnsNode = zodTypeToRenderingNode(columnsZodType);\n  assert(columnsNode.children !== undefined, \"columnsNode.children is undefined\");\n  columnsNode.children = columnsNode.children.map((child) => {\n    if (child.renderType === \"object\") {\n      assert(child.children !== undefined, \"child.children is undefined\");\n      const pickedCol = child.children.find((cc) => [\"title\", \"name\"].includes(cc.name));\n      if (pickedCol) {\n        return {\n          ...child,\n          renderType: \"object-pick\",\n          config: {\n            picked: pickedCol.name,\n          },\n        };\n      } else {\n        return child;\n      }\n    } else if (\n      child.renderType === \"array\" &&\n      child.element &&\n      child.element.renderType === \"object\"\n    ) {\n      const pickedCol = child.element?.children?.find((cc) => [\"title\", \"name\"].includes(cc.name));\n      if (pickedCol) {\n        return {\n          ...child,\n          element: {\n            ...child.element,\n            renderType: \"object-pick\",\n            config: {\n              picked: pickedCol.name,\n            },\n          },\n        };\n      } else {\n        return child;\n      }\n    }\n    return child;\n  });\n\n  return columnsNode;\n}\n\n/**\n * EntityPropNode를 Zod 타입으로 변환합니다.\n * plain, array, object 세 가지 nodeType을 재귀적으로 처리합니다.\n */\nexport async function propNodeToZodType(propNode: EntityPropNode): Promise<z.ZodTypeAny> {\n  if (propNode.nodeType === \"plain\") {\n    return propToZodType(propNode.prop);\n  } else if (propNode.nodeType === \"array\") {\n    if (propNode.prop === undefined) {\n      throw new Error();\n    } else if (propNode.children.length > 0) {\n      return (\n        await propNodeToZodType({\n          ...propNode,\n          nodeType: \"object\",\n        })\n      ).array();\n    } else {\n      const innerType = await propToZodType(propNode.prop);\n      if (propNode.prop.nullable === true) {\n        return z.array(innerType).nullable();\n      } else {\n        return z.array(innerType);\n      }\n    }\n  } else if (propNode.nodeType === \"object\") {\n    const entries = await Promise.all(\n      propNode.children.map(async (childPropNode) => {\n        assert(childPropNode.prop?.name !== undefined, \"childPropNode.prop.name is undefined\");\n        return [childPropNode.prop.name, await propNodeToZodType(childPropNode)] as const;\n      }),\n    );\n    const obj = Object.fromEntries(entries);\n\n    if (propNode.prop?.nullable === true) {\n      return z.object(obj).nullable();\n    } else {\n      return z.object(obj);\n    }\n  } else {\n    throw Error;\n  }\n}\n"],"names":["assert","z","SD","EntityManager","ServiceUnavailableException","propToZodType","zodTypeToRenderingNode","getColumnsNode","entityId","subsetKey","entity","get","subset","subsets","undefined","propNodes","fieldExprsToPropNodes","rootPropNode","nodeType","children","columnsZodType","propNodeToZodType","columnsNode","map","child","renderType","pickedCol","find","cc","includes","name","config","picked","element","propNode","prop","Error","length","array","innerType","nullable","entries","Promise","all","childPropNode","obj","Object","fromEntries","object"],"mappings":"AAAA,OAAOA,YAAY,SAAS;AAC5B,OAAOC,OAAO,MAAM;AACpB,SAASC,EAAE,QAAQ,gBAAa;AAChC,SAASC,aAAa,QAAQ,8BAA2B;AACzD,SAASC,2BAA2B,QAAQ,iCAA8B;AAE1E,SAASC,aAAa,EAAEC,sBAAsB,QAAQ,qBAAkB;AAExE;;;;CAIC,GACD,OAAO,eAAeC,eAAeC,QAAgB,EAAEC,SAAiB;IACtE,MAAMC,SAASP,cAAcQ,GAAG,CAACH;IACjC,MAAMI,SAASF,OAAOG,OAAO,CAACJ,UAAU;IACxC,IAAIG,WAAWE,WAAW;QACxB,MAAM,IAAIV,4BAA4BF,GAAG,+BAA+BO;IAC1E;IACA,MAAMM,YAAYL,OAAOM,qBAAqB,CAACJ;IAC/C,MAAMK,eAA+B;QACnCC,UAAU;QACVC,UAAUJ;IACZ;IAEA,qEAAqE;IACrE,MAAMK,iBAAkB,MAAMC,kBAAkBJ;IAEhD,MAAMK,cAAchB,uBAAuBc;IAC3CpB,OAAOsB,YAAYH,QAAQ,KAAKL,WAAW;IAC3CQ,YAAYH,QAAQ,GAAGG,YAAYH,QAAQ,CAACI,GAAG,CAAC,CAACC;QAC/C,IAAIA,MAAMC,UAAU,KAAK,UAAU;YACjCzB,OAAOwB,MAAML,QAAQ,KAAKL,WAAW;YACrC,MAAMY,YAAYF,MAAML,QAAQ,CAACQ,IAAI,CAAC,CAACC,KAAO;oBAAC;oBAAS;iBAAO,CAACC,QAAQ,CAACD,GAAGE,IAAI;YAChF,IAAIJ,WAAW;gBACb,OAAO;oBACL,GAAGF,KAAK;oBACRC,YAAY;oBACZM,QAAQ;wBACNC,QAAQN,UAAUI,IAAI;oBACxB;gBACF;YACF,OAAO;gBACL,OAAON;YACT;QACF,OAAO,IACLA,MAAMC,UAAU,KAAK,WACrBD,MAAMS,OAAO,IACbT,MAAMS,OAAO,CAACR,UAAU,KAAK,UAC7B;YACA,MAAMC,YAAYF,MAAMS,OAAO,EAAEd,UAAUQ,KAAK,CAACC,KAAO;oBAAC;oBAAS;iBAAO,CAACC,QAAQ,CAACD,GAAGE,IAAI;YAC1F,IAAIJ,WAAW;gBACb,OAAO;oBACL,GAAGF,KAAK;oBACRS,SAAS;wBACP,GAAGT,MAAMS,OAAO;wBAChBR,YAAY;wBACZM,QAAQ;4BACNC,QAAQN,UAAUI,IAAI;wBACxB;oBACF;gBACF;YACF,OAAO;gBACL,OAAON;YACT;QACF;QACA,OAAOA;IACT;IAEA,OAAOF;AACT;AAEA;;;CAGC,GACD,OAAO,eAAeD,kBAAkBa,QAAwB;IAC9D,IAAIA,SAAShB,QAAQ,KAAK,SAAS;QACjC,OAAOb,cAAc6B,SAASC,IAAI;IACpC,OAAO,IAAID,SAAShB,QAAQ,KAAK,SAAS;QACxC,IAAIgB,SAASC,IAAI,KAAKrB,WAAW;YAC/B,MAAM,IAAIsB;QACZ,OAAO,IAAIF,SAASf,QAAQ,CAACkB,MAAM,GAAG,GAAG;YACvC,OAAO,AACL,CAAA,MAAMhB,kBAAkB;gBACtB,GAAGa,QAAQ;gBACXhB,UAAU;YACZ,EAAC,EACDoB,KAAK;QACT,OAAO;YACL,MAAMC,YAAY,MAAMlC,cAAc6B,SAASC,IAAI;YACnD,IAAID,SAASC,IAAI,CAACK,QAAQ,KAAK,MAAM;gBACnC,OAAOvC,EAAEqC,KAAK,CAACC,WAAWC,QAAQ;YACpC,OAAO;gBACL,OAAOvC,EAAEqC,KAAK,CAACC;YACjB;QACF;IACF,OAAO,IAAIL,SAAShB,QAAQ,KAAK,UAAU;QACzC,MAAMuB,UAAU,MAAMC,QAAQC,GAAG,CAC/BT,SAASf,QAAQ,CAACI,GAAG,CAAC,OAAOqB;YAC3B5C,OAAO4C,cAAcT,IAAI,EAAEL,SAAShB,WAAW;YAC/C,OAAO;gBAAC8B,cAAcT,IAAI,CAACL,IAAI;gBAAE,MAAMT,kBAAkBuB;aAAe;QAC1E;QAEF,MAAMC,MAAMC,OAAOC,WAAW,CAACN;QAE/B,IAAIP,SAASC,IAAI,EAAEK,aAAa,MAAM;YACpC,OAAOvC,EAAE+C,MAAM,CAACH,KAAKL,QAAQ;QAC/B,OAAO;YACL,OAAOvC,EAAE+C,MAAM,CAACH;QAClB;IACF,OAAO;QACL,MAAMT;IACR;AACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/template/entity-converter.ts"],"sourcesContent":["import assert from \"assert\";\nimport z from \"zod\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { ServiceUnavailableException } from \"../exceptions/so-exceptions\";\nimport type { EntityPropNode, RenderingNode } from \"../types/types\";\nimport { propToZodType, zodTypeToRenderingNode } from \"./zod-converter\";\n\n/**\n * 엔티티의 특정 subset을 RenderingNode로 변환합니다.\n * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.\n * object와 array의 경우 적절한 pick 필드를 자동으로 선택합니다.\n */\nexport async function getColumnsNode(entityId: string, subsetKey: string): Promise<RenderingNode> {\n  const entity = EntityManager.get(entityId);\n  const subsetDef = entity.subsets[subsetKey];\n  if (subsetDef === undefined) {\n    throw new ServiceUnavailableException(SD(\"sonamu.error.subsetNotFound\")(subsetKey));\n  }\n  const propNodes = entity.fieldExprsToPropNodes(subsetDef);\n  const rootPropNode: EntityPropNode = {\n    nodeType: \"object\",\n    children: propNodes,\n  };\n\n  // biome-ignore lint/suspicious/noExplicitAny: zod 스키마를 로드할 때 사용하는 타입\n  const columnsZodType = (await propNodeToZodType(rootPropNode)) as z.ZodObject<any>;\n\n  const columnsNode = zodTypeToRenderingNode(columnsZodType);\n  assert(columnsNode.children !== undefined, \"columnsNode.children is undefined\");\n  columnsNode.children = columnsNode.children.map((child) => {\n    if (child.renderType === \"object\") {\n      assert(child.children !== undefined, \"child.children is undefined\");\n      const pickedCol = child.children.find((cc) => [\"title\", \"name\"].includes(cc.name));\n      if (pickedCol) {\n        return {\n          ...child,\n          renderType: \"object-pick\",\n          config: {\n            picked: pickedCol.name,\n          },\n        };\n      } else {\n        return child;\n      }\n    } else if (\n      child.renderType === \"array\" &&\n      child.element &&\n      child.element.renderType === \"object\"\n    ) {\n      const pickedCol = child.element?.children?.find((cc) => [\"title\", \"name\"].includes(cc.name));\n      if (pickedCol) {\n        return {\n          ...child,\n          element: {\n            ...child.element,\n            renderType: \"object-pick\",\n            config: {\n              picked: pickedCol.name,\n            },\n          },\n        };\n      } else {\n        return child;\n      }\n    }\n    return child;\n  });\n\n  return columnsNode;\n}\n\n/**\n * EntityPropNode를 Zod 타입으로 변환합니다.\n * plain, array, object 세 가지 nodeType을 재귀적으로 처리합니다.\n */\nexport async function propNodeToZodType(propNode: EntityPropNode): Promise<z.ZodTypeAny> {\n  if (propNode.nodeType === \"plain\") {\n    return propToZodType(propNode.prop);\n  } else if (propNode.nodeType === \"array\") {\n    if (propNode.prop === undefined) {\n      throw new Error();\n    } else if (propNode.children.length > 0) {\n      return (\n        await propNodeToZodType({\n          ...propNode,\n          nodeType: \"object\",\n        })\n      ).array();\n    } else {\n      const innerType = await propToZodType(propNode.prop);\n      if (propNode.prop.nullable === true) {\n        return z.array(innerType).nullable();\n      } else {\n        return z.array(innerType);\n      }\n    }\n  } else if (propNode.nodeType === \"object\") {\n    const entries = await Promise.all(\n      propNode.children.map(async (childPropNode) => {\n        assert(childPropNode.prop?.name !== undefined, \"childPropNode.prop.name is undefined\");\n        return [childPropNode.prop.name, await propNodeToZodType(childPropNode)] as const;\n      }),\n    );\n    const obj = Object.fromEntries(entries);\n\n    if (propNode.prop?.nullable === true) {\n      return z.object(obj).nullable();\n    } else {\n      return z.object(obj);\n    }\n  } else {\n    throw Error;\n  }\n}\n"],"names":["assert","z","SD","EntityManager","ServiceUnavailableException","propToZodType","zodTypeToRenderingNode","getColumnsNode","entityId","subsetKey","entity","get","subsetDef","subsets","undefined","propNodes","fieldExprsToPropNodes","rootPropNode","nodeType","children","columnsZodType","propNodeToZodType","columnsNode","map","child","renderType","pickedCol","find","cc","includes","name","config","picked","element","propNode","prop","Error","length","array","innerType","nullable","entries","Promise","all","childPropNode","obj","Object","fromEntries","object"],"mappings":"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"}

package/dist/template/helpers.d.ts

@@ -20,6 +20,16 @@ export declare function getEnumInfoFromColName(entityId: string, colName: string
  * 관계형 prop이 아닌 경우 에러를 발생시킵니다.
  */
 export declare function getRelationPropFromColName(entityId: string, colName: string): RelationProp;
+/**
+ * FK 컬럼명에서 실제 relation 이름을 추출합니다.
+ * BelongsToOne/OneToOne relation은 subset에서 FK 컬럼명(user_id)으로 생성되므로 변환이 필요하고,
+ * ManyToMany relation은 subset에서 relation명(employee)으로 생성되므로 변환이 불필요합니다.
+ *
+ * @example
+ * getRelationNameFromColumnName("Employee", "user_id") // "user"
+ * getRelationNameFromColumnName("Project", "tag_ids") // "tags"
+ */
+export declare function getRelationNameFromColumnName(entityId: string, colName: string): string;
 /**
  * 소스 코드에서 객체 선언을 추출합니다.
  * 중괄호 카운팅 방식으로 중첩된 객체도 정확히 파싱합니다.

package/dist/template/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/template/helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE/E;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAcjE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd;IACD,EAAE,EAAE,MAAM,CAAC;IACX,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,CAuBA;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,CAY1F;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA0EpF"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/template/helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE/E;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAcjE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd;IACD,EAAE,EAAE,MAAM,CAAC;IACX,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,CAuBA;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,CAY1F;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAsCvF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA0EpF"}