sonamu 0.7.16 → 0.7.18

package/dist/api/sonamu.js

@@ -263,7 +263,7 @@ class SonamuClass {
                 }
                 const found = this.syncer.apis.find((api)=>this.config.api.route.prefix + api.path === request.url.split("?")[0] && (api.options.httpMethod ?? "GET") === request.method.toUpperCase());
                 if (found) {
-                    return this.getApiHandler(found, config)(request, reply);
+                    return this.createApiHandler(found, config)(request, reply);
                 }
                 if (request.url.startsWith("/api/")) {
                     const { NotFoundException } = await import("../exceptions/so-exceptions.js");
@@ -282,12 +282,12 @@ class SonamuClass {
                 server.route({
                     method: api.options.httpMethod ?? "GET",
                     url: this.config.api.route.prefix + api.path,
-                    handler: this.getApiHandler(api, config)
+                    handler: this.createApiHandler(api, config)
                 }); // END server.route
             }
         }
     }
-    getApiHandler(api, config) {
+    createApiHandler(api, config) {
         return async (request, reply)=>{
             (api.options.guards ?? []).every((guard)=>config.guardHandler(guard, request, api));
             // 파라미터 정보로 zod 스키마 빌드
@@ -314,42 +314,52 @@ class SonamuClass {
             }
             // Content-Type
             reply.type(api.options.contentType ?? "application/json");
-            // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.
-            const { createSSEFactory } = await import("../stream/sse.js");
-            const createSSE = ((_request, _reply, _events)=>createSSEFactory(_request.socket, _reply, _events)).bind(null, request, reply);
-            const context = {
-                ...await Promise.resolve(config.contextProvider({
-                    request,
-                    reply,
-                    headers: request.headers,
-                    createSSE,
-                    naiteStore: Naite.createStore(),
-                    // auth
-                    user: request.user ?? null,
-                    passport: {
-                        login: request.login.bind(request),
-                        logout: request.logout.bind(request)
-                    }
-                }, request, reply))
-            };
-            const model = this.syncer.models[api.modelName];
-            return this.asyncLocalStorage.run({
-                context
-            }, async ()=>{
-                const { ApiParamType } = await import("../types/types.js");
-                // biome-ignore lint/suspicious/noExplicitAny: model은 모델 인스턴스이므로 메서드 호출 가능
-                const result = await model[api.methodName].apply(model, api.parameters.map((param)=>{
-                    // Context 인젝션
-                    if (ApiParamType.isContext(param.type)) {
-                        return context;
-                    } else {
-                        return reqBody[param.name];
-                    }
-                }));
-                reply.type(api.options.contentType ?? "application/json");
-                return result;
+            // Context 생성
+            const context = await this.createContext(config, request, reply);
+            // 모델 메소드 args 생성하여 호출
+            const { ApiParamType } = await import("../types/types.js");
+            const args = api.parameters.map((param)=>{
+                // Context 인젝션
+                if (ApiParamType.isContext(param.type)) {
+                    return context;
+                } else {
+                    return reqBody[param.name];
+                }
             });
+            return this.invokeModelMethod(api, args, context, reply);
+        };
+    }
+    async invokeModelMethod(api, args, context, reply) {
+        const model = this.syncer.models[api.modelName];
+        return this.asyncLocalStorage.run({
+            context
+        }, async ()=>{
+            // biome-ignore lint/suspicious/noExplicitAny: model은 모델 인스턴스이므로 메서드 호출 가능
+            const result = await model[api.methodName].apply(model, args);
+            reply.type(api.options.contentType ?? "application/json");
+            return result;
+        });
+    }
+    async createContext(config, request, reply) {
+        // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.
+        const { createSSEFactory } = await import("../stream/sse.js");
+        const createSSE = ((_request, _reply, _events)=>createSSEFactory(_request.socket, _reply, _events)).bind(null, request, reply);
+        const context = {
+            ...await Promise.resolve(config.contextProvider({
+                request,
+                reply,
+                headers: request.headers,
+                createSSE,
+                naiteStore: Naite.createStore(),
+                // auth
+                user: request.user ?? null,
+                passport: {
+                    login: request.login.bind(request),
+                    logout: request.logout.bind(request)
+                }
+            }, request, reply))
         };
+        return context;
     }
     async startWatcher() {
         const watchPath = [
@@ -527,4 +537,4 @@ class SonamuClass {
 }
 export const Sonamu = new SonamuClass();
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/sonamu.ts"],"sourcesContent":["import assert from \"assert\";\nimport { AsyncLocalStorage } from \"async_hooks\";\nimport type { FSWatcher } from \"chokidar\";\nimport type { FastifyInstance, FastifyReply, FastifyRequest } from \"fastify\";\nimport type { IncomingMessage, Server, ServerResponse } from \"http\";\nimport os from \"os\";\nimport path from \"path\";\nimport type { ZodObject } from \"zod\";\nimport { createMockSSEFactory, DB, isDaemonServer } from \"..\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport type { Driver } from \"../file-storage/driver\";\nimport { Naite } from \"../naite/naite\";\nimport type { Syncer } from \"../syncer/syncer\";\nimport type { WorkflowManager } from \"../tasks/workflow-manager\";\nimport type { SonamuFastifyConfig } from \"../types/types\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\nimport type { SonamuConfig, SonamuServerOptions, SonamuTaskOptions } from \"./config\";\nimport type { AuthContext, Context, UploadContext } from \"./context\";\nimport type { ExtendedApi } from \"./decorators\";\n\nexport type SonamuSecrets = {\n  anthropic_api_key?: string;\n  voyage_api_key?: string;\n  openai_api_key?: string;\n};\nclass SonamuClass {\n  public isInitialized: boolean = false;\n  public asyncLocalStorage: AsyncLocalStorage<{\n    context: Context;\n  }> = new AsyncLocalStorage();\n\n  public uploadStorage: AsyncLocalStorage<{\n    uploadContext: UploadContext;\n  }> = new AsyncLocalStorage();\n\n  public getContext(): Context {\n    const store = this.asyncLocalStorage.getStore();\n    if (store?.context) {\n      return store.context;\n    }\n\n    if (process.env.NODE_ENV === \"test\") {\n      // 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n      return {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        // biome-ignore lint/suspicious/noExplicitAny: 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n        naiteStore: new Map<string, any>(),\n      } as unknown as Context;\n    } else {\n      throw new Error(\"Sonamu cannot find context\");\n    }\n  }\n\n  public getUploadContext(): UploadContext {\n    const store = this.uploadStorage.getStore();\n    if (store?.uploadContext) {\n      return store.uploadContext;\n    }\n    throw new Error(\"Sonamu cannot find upload context. Did you use @upload decorator?\");\n  }\n\n  private _apiRootPath: AbsolutePath | null = null;\n  set apiRootPath(apiRootPath: AbsolutePath) {\n    this._apiRootPath = apiRootPath;\n  }\n  get apiRootPath(): AbsolutePath {\n    if (this._apiRootPath === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._apiRootPath;\n  }\n  get appRootPath(): string {\n    return this.apiRootPath.split(path.sep).slice(0, -1).join(path.sep);\n  }\n\n  private _dbConfig: SonamuDBConfig | null = null;\n  set dbConfig(dbConfig: SonamuDBConfig) {\n    this._dbConfig = dbConfig;\n  }\n  get dbConfig(): SonamuDBConfig {\n    if (this._dbConfig === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._dbConfig;\n  }\n\n  private _syncer: Syncer | null = null;\n  set syncer(syncer: Syncer) {\n    this._syncer = syncer;\n  }\n  get syncer(): Syncer {\n    if (this._syncer === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._syncer;\n  }\n\n  private _config: SonamuConfig | null = null;\n  set config(config: SonamuConfig) {\n    this._config = config;\n  }\n  get config(): SonamuConfig {\n    if (this._config === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._config;\n  }\n\n  private _secrets: SonamuSecrets | null = null;\n  set secrets(secrets: SonamuSecrets) {\n    this._secrets = secrets;\n  }\n  get secrets(): SonamuSecrets | null {\n    return this._secrets;\n  }\n\n  private _storage: Driver | null = null;\n  set storage(storage: Driver) {\n    this._storage = storage;\n  }\n  get storage(): Driver | null {\n    return this._storage;\n  }\n\n  private _workflows: WorkflowManager | null = null;\n  get workflows(): WorkflowManager {\n    if (this._workflows === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n\n    return this._workflows;\n  }\n\n  // HMR 처리\n  public watcher: FSWatcher | null = null;\n  private pendingFiles: string[] = [];\n  private hmrStartTime: number = 0;\n\n  public server: FastifyInstance | null = null;\n\n  async initForTesting() {\n    await this.init(true, false, undefined, true);\n  }\n\n  async init(\n    doSilent: boolean = false,\n    enableSync: boolean = true,\n    apiRootPath?: AbsolutePath,\n    forTesting: boolean = false,\n  ) {\n    if (this.isInitialized) {\n      return;\n    }\n\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.time(chalk.cyan(`Sonamu.init${forTesting ? \" for testing\" : \"\"}`));\n    }\n\n    // API 루트 패스\n    const { findApiRootPath } = await import(\"../utils/utils\");\n    this.apiRootPath = apiRootPath ?? findApiRootPath();\n\n    const { loadConfig } = await import(\"./config\");\n    this.config = await loadConfig(this.apiRootPath);\n    // sonamu.config.ts 기본값 설정\n    this.config.database.database = this.config.database.database ?? \"postgresql\";\n\n    // API 키 환경변수 로드\n    const secrets: SonamuSecrets = {};\n    if (process.env.ANTHROPIC_API_KEY) {\n      secrets.anthropic_api_key = process.env.ANTHROPIC_API_KEY;\n    }\n    if (process.env.VOYAGE_API_KEY) {\n      secrets.voyage_api_key = process.env.VOYAGE_API_KEY;\n    }\n    if (process.env.OPENAI_API_KEY) {\n      secrets.openai_api_key = process.env.OPENAI_API_KEY;\n    }\n    if (Object.keys(secrets).length > 0) {\n      this.secrets = secrets;\n    }\n\n    // DB 로드\n    const { DB } = await import(\"../database/db\");\n    this.dbConfig = DB.generateDBConfig(this.config.database);\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.log(chalk.green(\"DB Config Loaded!\"));\n    }\n\n    // Entity 로드\n    // 테스트에서도 Entity 정보는 필요합니다.\n    // upsert가 제대로 작동하려면 entity의 unique index 정보가 필요하기 때문입니다.\n    const { EntityManager } = await import(\"../entity/entity-manager\");\n    await EntityManager.autoload(doSilent);\n\n    // 테스팅인 경우 싱크 없이 중단\n    if (forTesting) {\n      this.isInitialized = true;\n      return;\n    }\n\n    // Task 등록\n    await this.initializeWorkflows(this.config.tasks);\n\n    // Syncer\n    const { Syncer } = await import(\"../syncer/syncer\");\n    this.syncer = new Syncer();\n\n    // Autoload: Models / Types / APIs\n    await this.syncer.autoloadTypes();\n    await this.syncer.autoloadModels();\n    await this.syncer.autoloadApis();\n    await this.syncer.autoloadWorkflows();\n\n    const { TemplateManager } = await import(\"../template\");\n    await TemplateManager.autoload();\n\n    const { isLocal, isTest } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      // 로컬에서는 코드 생성을 위해 Biome 셋업이 필요함 (현재 apiRootPath 전달하여 실행)\n      (await import(\"../utils/formatter\")).setupBiome(this.apiRootPath);\n    }\n\n    const { isHotReloadServer } = await import(\"../utils/controller\");\n    if (isLocal() && !isTest() && isHotReloadServer() && enableSync) {\n      await this.syncer.sync();\n\n      await this.startWatcher();\n    }\n\n    this.isInitialized = true;\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.timeEnd(chalk.cyan(\"Sonamu.init\"));\n    }\n  }\n\n  async createServer(initOptions?: { enableSync?: boolean; doSilent?: boolean }) {\n    if (this.isInitialized === false) {\n      await this.init(initOptions?.doSilent, initOptions?.enableSync);\n    }\n\n    const options = this.config.server;\n    const fastify = (await import(\"fastify\")).default;\n    const server = fastify(options.fastify);\n    this.server = server;\n\n    // Storage 설정 저장\n    if (options.storage) {\n      this.storage = options.storage;\n    }\n\n    // 플러그인 등록\n    if (options.plugins) {\n      await this.registerPlugins(server, options.plugins);\n    }\n\n    if (options.auth) {\n      if (!options.plugins?.session) {\n        throw new Error(\"Auth requires session plugin. Please add plugins.session configuration.\");\n      }\n\n      await this.registerAuth(server, options.auth);\n    }\n\n    // API 라우팅 설정\n    await this.withFastify(server, options.apiConfig, {\n      enableSync: initOptions?.enableSync,\n      doSilent: initOptions?.doSilent,\n    });\n\n    // 서버 시작\n    await this.boot(server, options);\n\n    return server;\n  }\n\n  async withFastify(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    config: SonamuFastifyConfig,\n    options?: {\n      enableSync?: boolean;\n      doSilent?: boolean;\n    },\n  ) {\n    if (this.isInitialized === false) {\n      await this.init(options?.doSilent, options?.enableSync);\n    }\n\n    this.server = server;\n\n    // timezone 설정\n    const timezone = this.config.api.timezone;\n    if (timezone) {\n      // 타임존에 맞게 응답 날짜 스트링을 변환해주어야 합니다.\n      // 가령 timezone이 \"Asia/Seoul\" 이면\n      // \"2025-11-21T00:00:00.000Z\" 를 \"2025-11-21T09:00:00+09:00\" 으로 변환해주어야 합니다.\n      const { formatInTimeZone } = await import(\"date-fns-tz\");\n\n      // ISO 8601 날짜 형식 정규식 (예: 2024-01-15T09:30:00.000Z)\n      const ISO_DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{3})?Z$/;\n\n      // T를 둘러싼 작은따옴표가 없다면 \"2025-11-19176354618900018:56:29+09:00\"와 같은 결과가 나옵니다.\n      // 이는 date-fns 특입니다.\n      // 이렇게 해도 괜찮습니다. \"2025-11-19T18:56:29+09:00\" 모양으로 잘 나옵니다.\n      const DATE_FORMAT = \"yyyy-MM-dd'T'HH:mm:ssXXX\";\n\n      server.setReplySerializer((payload) => {\n        return JSON.stringify(payload, (_key, value) => {\n          if (typeof value === \"string\" && ISO_DATE_REGEX.test(value)) {\n            return formatInTimeZone(\n              new Date(value),\n              timezone as `${string}/${string}`,\n              DATE_FORMAT,\n            );\n          }\n          return value;\n        });\n      });\n      if (!options?.doSilent) {\n        const chalk = (await import(\"chalk\")).default;\n        console.log(chalk.green(`Timezone set to ${timezone}`));\n      }\n    }\n\n    // 전체 라우팅 리스트\n    server.get(\n      `${this.config.api.route.prefix}/routes`,\n      async (_request, _reply): Promise<typeof this.syncer.apis> => {\n        return this.syncer.apis;\n      },\n    );\n\n    // Healthcheck API\n    server.get(\n      `${this.config.api.route.prefix}/healthcheck`,\n      async (_request, _reply): Promise<string> => {\n        return \"ok\";\n      },\n    );\n\n    // Sonamu UI API\n    const { sonamuUIApiPlugin } = await import(\"../ui/api\");\n    server.register(sonamuUIApiPlugin);\n\n    // API 라우팅 (로컬HMR 상태와 구분)\n    const { isLocal } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      server.all(\"*\", async (request, reply) => {\n        // Sonamu UI\n        if (request.url.startsWith(\"/sonamu-ui\")) {\n          return;\n        }\n\n        const found = this.syncer.apis.find(\n          (api) =>\n            this.config.api.route.prefix + api.path === request.url.split(\"?\")[0] &&\n            (api.options.httpMethod ?? \"GET\") === request.method.toUpperCase(),\n        );\n        if (found) {\n          return this.getApiHandler(found, config)(request, reply);\n        }\n\n        if (request.url.startsWith(\"/api/\")) {\n          const { NotFoundException } = await import(\"../exceptions/so-exceptions\");\n          throw new NotFoundException(`존재하지 않는 API 접근입니다. ${request.url}`);\n        }\n\n        // 일반 파일 접근시 별도의 에러 출력하지 않음\n        return;\n      });\n    } else {\n      for (const api of this.syncer.apis) {\n        // model\n        if (this.syncer.models[api.modelName] === undefined) {\n          throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);\n        }\n\n        // route\n        server.route({\n          method: api.options.httpMethod ?? \"GET\",\n          url: this.config.api.route.prefix + api.path,\n          handler: this.getApiHandler(api, config),\n        }); // END server.route\n      }\n    }\n  }\n\n  getApiHandler(\n    api: ExtendedApi,\n    config: SonamuFastifyConfig,\n  ): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown> {\n    return async (request: FastifyRequest, reply: FastifyReply): Promise<unknown> => {\n      (api.options.guards ?? []).every((guard) => config.guardHandler(guard, request, api));\n\n      // 파라미터 정보로 zod 스키마 빌드\n      const { getZodObjectFromApi } = await import(\"./code-converters\");\n      const ReqType = getZodObjectFromApi(api, this.syncer.types);\n\n      // request 파싱\n      const which = api.options.httpMethod === \"GET\" ? \"query\" : \"body\";\n      let reqBody: {\n        [key: string]: unknown;\n      };\n      try {\n        const { fastifyCaster } = await import(\"./caster\");\n        reqBody = fastifyCaster(ReqType).parse(request[which] ?? {});\n      } catch (e) {\n        const { ZodError } = await import(\"zod\");\n        if (e instanceof ZodError) {\n          const { humanizeZodError } = await import(\"../utils/zod-error\");\n          const messages = humanizeZodError(e)\n            .map((issue) => issue.message)\n            .join(\" \");\n          const { BadRequestException } = await import(\"../exceptions/so-exceptions\");\n          throw new BadRequestException(messages, {\n            zodError: e,\n          });\n        } else {\n          throw e;\n        }\n      }\n\n      // Content-Type\n      reply.type(api.options.contentType ?? \"application/json\");\n\n      // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.\n      const { createSSEFactory } = await import(\"../stream/sse\");\n      const createSSE = (<T extends ZodObject>(\n        _request: FastifyRequest,\n        _reply: FastifyReply,\n        _events: T,\n      ) => createSSEFactory(_request.socket, _reply, _events)).bind(null, request, reply);\n\n      const context: Context = {\n        ...(await Promise.resolve(\n          config.contextProvider(\n            {\n              request,\n              reply,\n              headers: request.headers,\n              createSSE,\n              naiteStore: Naite.createStore(),\n              // auth\n              user: request.user ?? null,\n              passport: {\n                login: request.login.bind(request) as AuthContext[\"passport\"][\"login\"],\n                logout: request.logout.bind(request) as AuthContext[\"passport\"][\"logout\"],\n              },\n            },\n            request,\n            reply,\n          ),\n        )),\n      };\n\n      const model = this.syncer.models[api.modelName];\n      return this.asyncLocalStorage.run({ context }, async () => {\n        const { ApiParamType } = await import(\"../types/types\");\n        // biome-ignore lint/suspicious/noExplicitAny: model은 모델 인스턴스이므로 메서드 호출 가능\n        const result = await (model as any)[api.methodName].apply(\n          model,\n          api.parameters.map((param) => {\n            // Context 인젝션\n            if (ApiParamType.isContext(param.type)) {\n              return context;\n            } else {\n              return reqBody[param.name];\n            }\n          }),\n        );\n        reply.type(api.options.contentType ?? \"application/json\");\n\n        return result;\n      });\n    };\n  }\n\n  async startWatcher(): Promise<void> {\n    const watchPath = [path.join(this.apiRootPath, \"src\")];\n\n    const chokidar = (await import(\"chokidar\")).default;\n    this.watcher = chokidar.watch(watchPath, {\n      ignored: (path, stats) =>\n        !!stats?.isFile() && !path.endsWith(\".ts\") && !path.endsWith(\".json\"),\n      persistent: true,\n      ignoreInitial: true,\n    });\n\n    this.watcher.on(\"all\", async (event: string, filePath: string) => {\n      const absolutePath = filePath as AbsolutePath;\n      assert(\n        absolutePath.startsWith(this.apiRootPath),\n        \"File path is not within the API root path\",\n      );\n\n      if (event !== \"change\" && event !== \"add\") {\n        return;\n      }\n\n      try {\n        // sonamu.config.ts 변경 시 재시작\n        const isConfigTs = filePath === path.join(this.apiRootPath, \"src\", \"sonamu.config.ts\");\n\n        if (isConfigTs) {\n          const relativePath = filePath.replace(this.apiRootPath, \"api\");\n          const chalk = (await import(\"chalk\")).default;\n          console.log(\n            chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`),\n          );\n          process.kill(process.pid, \"SIGUSR2\");\n          return;\n        }\n\n        await this.handleFileChange(event, absolutePath);\n      } catch (e) {\n        console.error(e);\n      }\n    });\n  }\n\n  /*\n     A function that automatically handles init and destroy when using Sonamu via scripts.    \n  */\n  async runScript(fn: () => Promise<void>) {\n    await this.init(true, false, undefined, false);\n    try {\n      await fn();\n    } finally {\n      await this.destroy();\n    }\n  }\n\n  private async registerPlugins(server: FastifyInstance, plugins: SonamuServerOptions[\"plugins\"]) {\n    if (!plugins) {\n      return;\n    }\n\n    const pluginsModules = {\n      cors: \"@fastify/cors\",\n      formbody: \"@fastify/formbody\",\n      multipart: \"@fastify/multipart\",\n      qs: \"fastify-qs\",\n      sse: \"fastify-sse-v2\",\n      static: \"@fastify/static\",\n      session: \"@fastify/secure-session\",\n    } as const;\n\n    const registerPlugin = async <K extends keyof NonNullable<typeof plugins>>(\n      key: K,\n      pluginName: string,\n    ) => {\n      const option = plugins[key];\n      if (!option) return;\n\n      if (option === true) {\n        server.register((await import(pluginName)).default);\n      } else {\n        server.register((await import(pluginName)).default, option);\n      }\n    };\n\n    for (const [key, pluginName] of Object.entries(pluginsModules)) {\n      await registerPlugin(key as keyof typeof plugins, pluginName);\n    }\n\n    if (plugins.custom) {\n      plugins.custom(server);\n    }\n  }\n\n  private async registerAuth(\n    server: FastifyInstance,\n    options: NonNullable<SonamuServerOptions[\"auth\"]>,\n  ) {\n    // await import(\"fastify\");\n    const fastifyPassport = (await import(\"@fastify/passport\")).default;\n    server.register(fastifyPassport.initialize());\n    server.register(fastifyPassport.secureSession());\n\n    if (typeof options === \"boolean\") {\n      fastifyPassport.registerUserSerializer(async (user, _request) => user);\n      fastifyPassport.registerUserDeserializer(async (serialized, _request) => serialized);\n    } else {\n      fastifyPassport.registerUserSerializer(options.userSerializer);\n      fastifyPassport.registerUserDeserializer(options.userDeserializer);\n    }\n  }\n\n  private async initializeWorkflows(options: SonamuTaskOptions | undefined) {\n    const { WorkflowManager } = await import(\"../tasks/workflow-manager\");\n    // NOTE: @sonamu-kit/tasks 안에선 knex config를 수정하기 때문에 connection이 아닌 config 째로 보냅니다.\n    this._workflows = new WorkflowManager(DB.getDBConfig(\"w\"));\n    if (!options) {\n      return;\n    }\n\n    const enableWorker = options.enableWorker ?? isDaemonServer();\n    const defaultWorkerOptions = {\n      concurrency: os.cpus().length - 1,\n      usePubSub: true,\n      listenDelay: 500,\n    };\n\n    if (enableWorker) {\n      this.workflows.setupWorker({\n        ...defaultWorkerOptions,\n        ...options.workerOptions,\n      });\n    }\n  }\n\n  private async boot(server: FastifyInstance, options: SonamuServerOptions) {\n    const port = options.listen?.port ?? 3000;\n    const host = options.listen?.host ?? \"localhost\";\n\n    server.addHook(\"onClose\", async () => {\n      await options.lifecycle?.onShutdown?.(server);\n      await this.workflows.destroy();\n      await this.destroy();\n    });\n\n    const shutdown = async () => {\n      try {\n        await server.close();\n        process.exit(0);\n      } catch (err) {\n        console.error(\"Error during shutdown:\", err);\n        process.exit(1);\n      }\n    };\n\n    process.on(\"SIGINT\", shutdown);\n    process.on(\"SIGTERM\", shutdown);\n\n    if (options.lifecycle?.onError) {\n      server.setErrorHandler(options.lifecycle?.onError);\n    }\n\n    server\n      .listen({ port, host })\n      .then(async () => {\n        await this.workflows.startWorker();\n        await options.lifecycle?.onStart?.(server);\n      })\n      .catch(async (err) => {\n        const chalk = (await import(\"chalk\")).default;\n        console.error(chalk.red(\"Failed to start server:\", err));\n        await shutdown();\n      });\n  }\n\n  private async handleFileChange(event: string, filePath: AbsolutePath): Promise<void> {\n    // 첫 번째 파일이면 HMR 시작 시간 기록\n    if (this.pendingFiles.length === 0) {\n      this.hmrStartTime = Date.now();\n    }\n    this.pendingFiles.push(filePath);\n\n    const relativePath = path.relative(this.apiRootPath, filePath);\n    const chalk = (await import(\"chalk\")).default;\n    console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));\n\n    await this.syncer.syncFromWatcher(event, filePath);\n\n    // 처리 완료된 파일을 대기 목록에서 제거\n    this.pendingFiles = this.pendingFiles.slice(1);\n\n    // 모든 파일 처리가 완료되면 최종 메시지 출력\n    if (this.pendingFiles.length === 0) {\n      await this.finishHMR();\n    }\n  }\n\n  private async finishHMR(): Promise<void> {\n    await this.syncer.renewChecksums();\n\n    const endTime = Date.now();\n    const totalTime = endTime - this.hmrStartTime;\n    const [chalk, { centerText }] = await Promise.all([\n      (await import(\"chalk\")).default,\n      import(\"../utils/console-util\"),\n    ]);\n    const msg = `HMR Done! ${chalk.bold.white(`${totalTime}ms`)}`;\n\n    console.log(chalk.black.bgGreen(centerText(msg)));\n  }\n\n  async destroy(): Promise<void> {\n    const { BaseModel } = await import(\"../database/base-model\");\n    await BaseModel.destroy();\n    await this._workflows?.destroy();\n    await this.watcher?.close();\n    this.storage?.destroy();\n  }\n}\nexport const Sonamu = new SonamuClass();\n"],"names":["assert","AsyncLocalStorage","os","path","createMockSSEFactory","DB","isDaemonServer","Naite","SonamuClass","isInitialized","asyncLocalStorage","uploadStorage","getContext","store","getStore","context","process","env","NODE_ENV","request","reply","headers","createSSE","schema","naiteStore","Map","Error","getUploadContext","uploadContext","_apiRootPath","apiRootPath","appRootPath","split","sep","slice","join","_dbConfig","dbConfig","_syncer","syncer","_config","config","_secrets","secrets","_storage","storage","_workflows","workflows","watcher","pendingFiles","hmrStartTime","server","initForTesting","init","undefined","doSilent","enableSync","forTesting","chalk","default","console","time","cyan","findApiRootPath","loadConfig","database","ANTHROPIC_API_KEY","anthropic_api_key","VOYAGE_API_KEY","voyage_api_key","OPENAI_API_KEY","openai_api_key","Object","keys","length","generateDBConfig","log","green","EntityManager","autoload","initializeWorkflows","tasks","Syncer","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","TemplateManager","isLocal","isTest","setupBiome","isHotReloadServer","sync","startWatcher","timeEnd","createServer","initOptions","options","fastify","plugins","registerPlugins","auth","session","registerAuth","withFastify","apiConfig","boot","timezone","api","formatInTimeZone","ISO_DATE_REGEX","DATE_FORMAT","setReplySerializer","payload","JSON","stringify","_key","value","test","Date","get","route","prefix","_request","_reply","apis","sonamuUIApiPlugin","register","all","url","startsWith","found","find","httpMethod","method","toUpperCase","getApiHandler","NotFoundException","models","modelName","handler","guards","every","guard","guardHandler","getZodObjectFromApi","ReqType","types","which","reqBody","fastifyCaster","parse","e","ZodError","humanizeZodError","messages","map","issue","message","BadRequestException","zodError","type","contentType","createSSEFactory","_events","socket","bind","Promise","resolve","contextProvider","createStore","user","passport","login","logout","model","run","ApiParamType","result","methodName","apply","parameters","param","isContext","name","watchPath","chokidar","watch","ignored","stats","isFile","endsWith","persistent","ignoreInitial","on","event","filePath","absolutePath","isConfigTs","relativePath","replace","bold","blue","kill","pid","handleFileChange","error","runScript","fn","destroy","pluginsModules","cors","formbody","multipart","qs","sse","static","registerPlugin","key","pluginName","option","entries","custom","fastifyPassport","initialize","secureSession","registerUserSerializer","registerUserDeserializer","serialized","userSerializer","userDeserializer","WorkflowManager","getDBConfig","enableWorker","defaultWorkerOptions","concurrency","cpus","usePubSub","listenDelay","setupWorker","workerOptions","port","listen","host","addHook","lifecycle","onShutdown","shutdown","close","exit","err","onError","setErrorHandler","then","startWorker","onStart","catch","red","now","push","relative","syncFromWatcher","finishHMR","renewChecksums","endTime","totalTime","centerText","msg","white","black","bgGreen","BaseModel","Sonamu"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/sonamu.ts"],"sourcesContent":["import assert from \"assert\";\nimport { AsyncLocalStorage } from \"async_hooks\";\nimport type { FSWatcher } from \"chokidar\";\nimport type { FastifyInstance, FastifyReply, FastifyRequest } from \"fastify\";\nimport type { IncomingMessage, Server, ServerResponse } from \"http\";\nimport os from \"os\";\nimport path from \"path\";\nimport type { ZodObject } from \"zod\";\nimport { createMockSSEFactory, DB, isDaemonServer } from \"..\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport type { Driver } from \"../file-storage/driver\";\nimport { Naite } from \"../naite/naite\";\nimport type { Syncer } from \"../syncer/syncer\";\nimport type { WorkflowManager } from \"../tasks/workflow-manager\";\nimport type { SonamuFastifyConfig } from \"../types/types\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\nimport type { SonamuConfig, SonamuServerOptions, SonamuTaskOptions } from \"./config\";\nimport type { AuthContext, Context, UploadContext } from \"./context\";\nimport type { ExtendedApi } from \"./decorators\";\n\nexport type SonamuSecrets = {\n  anthropic_api_key?: string;\n  voyage_api_key?: string;\n  openai_api_key?: string;\n};\nclass SonamuClass {\n  public isInitialized: boolean = false;\n  public asyncLocalStorage: AsyncLocalStorage<{\n    context: Context;\n  }> = new AsyncLocalStorage();\n\n  public uploadStorage: AsyncLocalStorage<{\n    uploadContext: UploadContext;\n  }> = new AsyncLocalStorage();\n\n  public getContext(): Context {\n    const store = this.asyncLocalStorage.getStore();\n    if (store?.context) {\n      return store.context;\n    }\n\n    if (process.env.NODE_ENV === \"test\") {\n      // 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n      return {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        // biome-ignore lint/suspicious/noExplicitAny: 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n        naiteStore: new Map<string, any>(),\n      } as unknown as Context;\n    } else {\n      throw new Error(\"Sonamu cannot find context\");\n    }\n  }\n\n  public getUploadContext(): UploadContext {\n    const store = this.uploadStorage.getStore();\n    if (store?.uploadContext) {\n      return store.uploadContext;\n    }\n    throw new Error(\"Sonamu cannot find upload context. Did you use @upload decorator?\");\n  }\n\n  private _apiRootPath: AbsolutePath | null = null;\n  set apiRootPath(apiRootPath: AbsolutePath) {\n    this._apiRootPath = apiRootPath;\n  }\n  get apiRootPath(): AbsolutePath {\n    if (this._apiRootPath === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._apiRootPath;\n  }\n  get appRootPath(): string {\n    return this.apiRootPath.split(path.sep).slice(0, -1).join(path.sep);\n  }\n\n  private _dbConfig: SonamuDBConfig | null = null;\n  set dbConfig(dbConfig: SonamuDBConfig) {\n    this._dbConfig = dbConfig;\n  }\n  get dbConfig(): SonamuDBConfig {\n    if (this._dbConfig === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._dbConfig;\n  }\n\n  private _syncer: Syncer | null = null;\n  set syncer(syncer: Syncer) {\n    this._syncer = syncer;\n  }\n  get syncer(): Syncer {\n    if (this._syncer === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._syncer;\n  }\n\n  private _config: SonamuConfig | null = null;\n  set config(config: SonamuConfig) {\n    this._config = config;\n  }\n  get config(): SonamuConfig {\n    if (this._config === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._config;\n  }\n\n  private _secrets: SonamuSecrets | null = null;\n  set secrets(secrets: SonamuSecrets) {\n    this._secrets = secrets;\n  }\n  get secrets(): SonamuSecrets | null {\n    return this._secrets;\n  }\n\n  private _storage: Driver | null = null;\n  set storage(storage: Driver) {\n    this._storage = storage;\n  }\n  get storage(): Driver | null {\n    return this._storage;\n  }\n\n  private _workflows: WorkflowManager | null = null;\n  get workflows(): WorkflowManager {\n    if (this._workflows === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n\n    return this._workflows;\n  }\n\n  // HMR 처리\n  public watcher: FSWatcher | null = null;\n  private pendingFiles: string[] = [];\n  private hmrStartTime: number = 0;\n\n  public server: FastifyInstance | null = null;\n\n  async initForTesting() {\n    await this.init(true, false, undefined, true);\n  }\n\n  async init(\n    doSilent: boolean = false,\n    enableSync: boolean = true,\n    apiRootPath?: AbsolutePath,\n    forTesting: boolean = false,\n  ) {\n    if (this.isInitialized) {\n      return;\n    }\n\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.time(chalk.cyan(`Sonamu.init${forTesting ? \" for testing\" : \"\"}`));\n    }\n\n    // API 루트 패스\n    const { findApiRootPath } = await import(\"../utils/utils\");\n    this.apiRootPath = apiRootPath ?? findApiRootPath();\n\n    const { loadConfig } = await import(\"./config\");\n    this.config = await loadConfig(this.apiRootPath);\n    // sonamu.config.ts 기본값 설정\n    this.config.database.database = this.config.database.database ?? \"postgresql\";\n\n    // API 키 환경변수 로드\n    const secrets: SonamuSecrets = {};\n    if (process.env.ANTHROPIC_API_KEY) {\n      secrets.anthropic_api_key = process.env.ANTHROPIC_API_KEY;\n    }\n    if (process.env.VOYAGE_API_KEY) {\n      secrets.voyage_api_key = process.env.VOYAGE_API_KEY;\n    }\n    if (process.env.OPENAI_API_KEY) {\n      secrets.openai_api_key = process.env.OPENAI_API_KEY;\n    }\n    if (Object.keys(secrets).length > 0) {\n      this.secrets = secrets;\n    }\n\n    // DB 로드\n    const { DB } = await import(\"../database/db\");\n    this.dbConfig = DB.generateDBConfig(this.config.database);\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.log(chalk.green(\"DB Config Loaded!\"));\n    }\n\n    // Entity 로드\n    // 테스트에서도 Entity 정보는 필요합니다.\n    // upsert가 제대로 작동하려면 entity의 unique index 정보가 필요하기 때문입니다.\n    const { EntityManager } = await import(\"../entity/entity-manager\");\n    await EntityManager.autoload(doSilent);\n\n    // 테스팅인 경우 싱크 없이 중단\n    if (forTesting) {\n      this.isInitialized = true;\n      return;\n    }\n\n    // Task 등록\n    await this.initializeWorkflows(this.config.tasks);\n\n    // Syncer\n    const { Syncer } = await import(\"../syncer/syncer\");\n    this.syncer = new Syncer();\n\n    // Autoload: Models / Types / APIs\n    await this.syncer.autoloadTypes();\n    await this.syncer.autoloadModels();\n    await this.syncer.autoloadApis();\n    await this.syncer.autoloadWorkflows();\n\n    const { TemplateManager } = await import(\"../template\");\n    await TemplateManager.autoload();\n\n    const { isLocal, isTest } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      // 로컬에서는 코드 생성을 위해 Biome 셋업이 필요함 (현재 apiRootPath 전달하여 실행)\n      (await import(\"../utils/formatter\")).setupBiome(this.apiRootPath);\n    }\n\n    const { isHotReloadServer } = await import(\"../utils/controller\");\n    if (isLocal() && !isTest() && isHotReloadServer() && enableSync) {\n      await this.syncer.sync();\n\n      await this.startWatcher();\n    }\n\n    this.isInitialized = true;\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.timeEnd(chalk.cyan(\"Sonamu.init\"));\n    }\n  }\n\n  async createServer(initOptions?: { enableSync?: boolean; doSilent?: boolean }) {\n    if (this.isInitialized === false) {\n      await this.init(initOptions?.doSilent, initOptions?.enableSync);\n    }\n\n    const options = this.config.server;\n    const fastify = (await import(\"fastify\")).default;\n    const server = fastify(options.fastify);\n    this.server = server;\n\n    // Storage 설정 저장\n    if (options.storage) {\n      this.storage = options.storage;\n    }\n\n    // 플러그인 등록\n    if (options.plugins) {\n      await this.registerPlugins(server, options.plugins);\n    }\n\n    if (options.auth) {\n      if (!options.plugins?.session) {\n        throw new Error(\"Auth requires session plugin. Please add plugins.session configuration.\");\n      }\n\n      await this.registerAuth(server, options.auth);\n    }\n\n    // API 라우팅 설정\n    await this.withFastify(server, options.apiConfig, {\n      enableSync: initOptions?.enableSync,\n      doSilent: initOptions?.doSilent,\n    });\n\n    // 서버 시작\n    await this.boot(server, options);\n\n    return server;\n  }\n\n  async withFastify(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    config: SonamuFastifyConfig,\n    options?: {\n      enableSync?: boolean;\n      doSilent?: boolean;\n    },\n  ) {\n    if (this.isInitialized === false) {\n      await this.init(options?.doSilent, options?.enableSync);\n    }\n\n    this.server = server;\n\n    // timezone 설정\n    const timezone = this.config.api.timezone;\n    if (timezone) {\n      // 타임존에 맞게 응답 날짜 스트링을 변환해주어야 합니다.\n      // 가령 timezone이 \"Asia/Seoul\" 이면\n      // \"2025-11-21T00:00:00.000Z\" 를 \"2025-11-21T09:00:00+09:00\" 으로 변환해주어야 합니다.\n      const { formatInTimeZone } = await import(\"date-fns-tz\");\n\n      // ISO 8601 날짜 형식 정규식 (예: 2024-01-15T09:30:00.000Z)\n      const ISO_DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{3})?Z$/;\n\n      // T를 둘러싼 작은따옴표가 없다면 \"2025-11-19176354618900018:56:29+09:00\"와 같은 결과가 나옵니다.\n      // 이는 date-fns 특입니다.\n      // 이렇게 해도 괜찮습니다. \"2025-11-19T18:56:29+09:00\" 모양으로 잘 나옵니다.\n      const DATE_FORMAT = \"yyyy-MM-dd'T'HH:mm:ssXXX\";\n\n      server.setReplySerializer((payload) => {\n        return JSON.stringify(payload, (_key, value) => {\n          if (typeof value === \"string\" && ISO_DATE_REGEX.test(value)) {\n            return formatInTimeZone(\n              new Date(value),\n              timezone as `${string}/${string}`,\n              DATE_FORMAT,\n            );\n          }\n          return value;\n        });\n      });\n      if (!options?.doSilent) {\n        const chalk = (await import(\"chalk\")).default;\n        console.log(chalk.green(`Timezone set to ${timezone}`));\n      }\n    }\n\n    // 전체 라우팅 리스트\n    server.get(\n      `${this.config.api.route.prefix}/routes`,\n      async (_request, _reply): Promise<typeof this.syncer.apis> => {\n        return this.syncer.apis;\n      },\n    );\n\n    // Healthcheck API\n    server.get(\n      `${this.config.api.route.prefix}/healthcheck`,\n      async (_request, _reply): Promise<string> => {\n        return \"ok\";\n      },\n    );\n\n    // Sonamu UI API\n    const { sonamuUIApiPlugin } = await import(\"../ui/api\");\n    server.register(sonamuUIApiPlugin);\n\n    // API 라우팅 (로컬HMR 상태와 구분)\n    const { isLocal } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      server.all(\"*\", async (request, reply) => {\n        // Sonamu UI\n        if (request.url.startsWith(\"/sonamu-ui\")) {\n          return;\n        }\n\n        const found = this.syncer.apis.find(\n          (api) =>\n            this.config.api.route.prefix + api.path === request.url.split(\"?\")[0] &&\n            (api.options.httpMethod ?? \"GET\") === request.method.toUpperCase(),\n        );\n        if (found) {\n          return this.createApiHandler(found, config)(request, reply);\n        }\n\n        if (request.url.startsWith(\"/api/\")) {\n          const { NotFoundException } = await import(\"../exceptions/so-exceptions\");\n          throw new NotFoundException(`존재하지 않는 API 접근입니다. ${request.url}`);\n        }\n\n        // 일반 파일 접근시 별도의 에러 출력하지 않음\n        return;\n      });\n    } else {\n      for (const api of this.syncer.apis) {\n        // model\n        if (this.syncer.models[api.modelName] === undefined) {\n          throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);\n        }\n\n        // route\n        server.route({\n          method: api.options.httpMethod ?? \"GET\",\n          url: this.config.api.route.prefix + api.path,\n          handler: this.createApiHandler(api, config),\n        }); // END server.route\n      }\n    }\n  }\n\n  createApiHandler(\n    api: ExtendedApi,\n    config: SonamuFastifyConfig,\n  ): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown> {\n    return async (request: FastifyRequest, reply: FastifyReply): Promise<unknown> => {\n      (api.options.guards ?? []).every((guard) => config.guardHandler(guard, request, api));\n\n      // 파라미터 정보로 zod 스키마 빌드\n      const { getZodObjectFromApi } = await import(\"./code-converters\");\n      const ReqType = getZodObjectFromApi(api, this.syncer.types);\n\n      // request 파싱\n      const which = api.options.httpMethod === \"GET\" ? \"query\" : \"body\";\n      let reqBody: {\n        [key: string]: unknown;\n      };\n      try {\n        const { fastifyCaster } = await import(\"./caster\");\n        reqBody = fastifyCaster(ReqType).parse(request[which] ?? {});\n      } catch (e) {\n        const { ZodError } = await import(\"zod\");\n        if (e instanceof ZodError) {\n          const { humanizeZodError } = await import(\"../utils/zod-error\");\n          const messages = humanizeZodError(e)\n            .map((issue) => issue.message)\n            .join(\" \");\n          const { BadRequestException } = await import(\"../exceptions/so-exceptions\");\n          throw new BadRequestException(messages, {\n            zodError: e,\n          });\n        } else {\n          throw e;\n        }\n      }\n\n      // Content-Type\n      reply.type(api.options.contentType ?? \"application/json\");\n\n      // Context 생성\n      const context: Context = await this.createContext(config, request, reply);\n\n      // 모델 메소드 args 생성하여 호출\n      const { ApiParamType } = await import(\"../types/types\");\n      const args = api.parameters.map((param) => {\n        // Context 인젝션\n        if (ApiParamType.isContext(param.type)) {\n          return context;\n        } else {\n          return reqBody[param.name];\n        }\n      });\n      return this.invokeModelMethod(api, args, context, reply);\n    };\n  }\n\n  async invokeModelMethod(\n    api: ExtendedApi,\n    args: unknown[],\n    context: Context,\n    reply: FastifyReply,\n  ): Promise<unknown> {\n    const model = this.syncer.models[api.modelName];\n    return this.asyncLocalStorage.run({ context }, async () => {\n      // biome-ignore lint/suspicious/noExplicitAny: model은 모델 인스턴스이므로 메서드 호출 가능\n      const result = await (model as any)[api.methodName].apply(model, args);\n      reply.type(api.options.contentType ?? \"application/json\");\n\n      return result;\n    });\n  }\n\n  async createContext(\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ): Promise<Context> {\n    // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.\n    const { createSSEFactory } = await import(\"../stream/sse\");\n    const createSSE = (<T extends ZodObject>(\n      _request: FastifyRequest,\n      _reply: FastifyReply,\n      _events: T,\n    ) => createSSEFactory(_request.socket, _reply, _events)).bind(null, request, reply);\n\n    const context: Context = {\n      ...(await Promise.resolve(\n        config.contextProvider(\n          {\n            request,\n            reply,\n            headers: request.headers,\n            createSSE,\n            naiteStore: Naite.createStore(),\n            // auth\n            user: request.user ?? null,\n            passport: {\n              login: request.login.bind(request) as AuthContext[\"passport\"][\"login\"],\n              logout: request.logout.bind(request) as AuthContext[\"passport\"][\"logout\"],\n            },\n          },\n          request,\n          reply,\n        ),\n      )),\n    };\n    return context;\n  }\n\n  async startWatcher(): Promise<void> {\n    const watchPath = [path.join(this.apiRootPath, \"src\")];\n\n    const chokidar = (await import(\"chokidar\")).default;\n    this.watcher = chokidar.watch(watchPath, {\n      ignored: (path, stats) =>\n        !!stats?.isFile() && !path.endsWith(\".ts\") && !path.endsWith(\".json\"),\n      persistent: true,\n      ignoreInitial: true,\n    });\n\n    this.watcher.on(\"all\", async (event: string, filePath: string) => {\n      const absolutePath = filePath as AbsolutePath;\n      assert(\n        absolutePath.startsWith(this.apiRootPath),\n        \"File path is not within the API root path\",\n      );\n\n      if (event !== \"change\" && event !== \"add\") {\n        return;\n      }\n\n      try {\n        // sonamu.config.ts 변경 시 재시작\n        const isConfigTs = filePath === path.join(this.apiRootPath, \"src\", \"sonamu.config.ts\");\n\n        if (isConfigTs) {\n          const relativePath = filePath.replace(this.apiRootPath, \"api\");\n          const chalk = (await import(\"chalk\")).default;\n          console.log(\n            chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`),\n          );\n          process.kill(process.pid, \"SIGUSR2\");\n          return;\n        }\n\n        await this.handleFileChange(event, absolutePath);\n      } catch (e) {\n        console.error(e);\n      }\n    });\n  }\n\n  /*\n     A function that automatically handles init and destroy when using Sonamu via scripts.    \n  */\n  async runScript(fn: () => Promise<void>) {\n    await this.init(true, false, undefined, false);\n    try {\n      await fn();\n    } finally {\n      await this.destroy();\n    }\n  }\n\n  private async registerPlugins(server: FastifyInstance, plugins: SonamuServerOptions[\"plugins\"]) {\n    if (!plugins) {\n      return;\n    }\n\n    const pluginsModules = {\n      cors: \"@fastify/cors\",\n      formbody: \"@fastify/formbody\",\n      multipart: \"@fastify/multipart\",\n      qs: \"fastify-qs\",\n      sse: \"fastify-sse-v2\",\n      static: \"@fastify/static\",\n      session: \"@fastify/secure-session\",\n    } as const;\n\n    const registerPlugin = async <K extends keyof NonNullable<typeof plugins>>(\n      key: K,\n      pluginName: string,\n    ) => {\n      const option = plugins[key];\n      if (!option) return;\n\n      if (option === true) {\n        server.register((await import(pluginName)).default);\n      } else {\n        server.register((await import(pluginName)).default, option);\n      }\n    };\n\n    for (const [key, pluginName] of Object.entries(pluginsModules)) {\n      await registerPlugin(key as keyof typeof plugins, pluginName);\n    }\n\n    if (plugins.custom) {\n      plugins.custom(server);\n    }\n  }\n\n  private async registerAuth(\n    server: FastifyInstance,\n    options: NonNullable<SonamuServerOptions[\"auth\"]>,\n  ) {\n    // await import(\"fastify\");\n    const fastifyPassport = (await import(\"@fastify/passport\")).default;\n    server.register(fastifyPassport.initialize());\n    server.register(fastifyPassport.secureSession());\n\n    if (typeof options === \"boolean\") {\n      fastifyPassport.registerUserSerializer(async (user, _request) => user);\n      fastifyPassport.registerUserDeserializer(async (serialized, _request) => serialized);\n    } else {\n      fastifyPassport.registerUserSerializer(options.userSerializer);\n      fastifyPassport.registerUserDeserializer(options.userDeserializer);\n    }\n  }\n\n  private async initializeWorkflows(options: SonamuTaskOptions | undefined) {\n    const { WorkflowManager } = await import(\"../tasks/workflow-manager\");\n    // NOTE: @sonamu-kit/tasks 안에선 knex config를 수정하기 때문에 connection이 아닌 config 째로 보냅니다.\n    this._workflows = new WorkflowManager(DB.getDBConfig(\"w\"));\n    if (!options) {\n      return;\n    }\n\n    const enableWorker = options.enableWorker ?? isDaemonServer();\n    const defaultWorkerOptions = {\n      concurrency: os.cpus().length - 1,\n      usePubSub: true,\n      listenDelay: 500,\n    };\n\n    if (enableWorker) {\n      this.workflows.setupWorker({\n        ...defaultWorkerOptions,\n        ...options.workerOptions,\n      });\n    }\n  }\n\n  private async boot(server: FastifyInstance, options: SonamuServerOptions) {\n    const port = options.listen?.port ?? 3000;\n    const host = options.listen?.host ?? \"localhost\";\n\n    server.addHook(\"onClose\", async () => {\n      await options.lifecycle?.onShutdown?.(server);\n      await this.workflows.destroy();\n      await this.destroy();\n    });\n\n    const shutdown = async () => {\n      try {\n        await server.close();\n        process.exit(0);\n      } catch (err) {\n        console.error(\"Error during shutdown:\", err);\n        process.exit(1);\n      }\n    };\n\n    process.on(\"SIGINT\", shutdown);\n    process.on(\"SIGTERM\", shutdown);\n\n    if (options.lifecycle?.onError) {\n      server.setErrorHandler(options.lifecycle?.onError);\n    }\n\n    server\n      .listen({ port, host })\n      .then(async () => {\n        await this.workflows.startWorker();\n        await options.lifecycle?.onStart?.(server);\n      })\n      .catch(async (err) => {\n        const chalk = (await import(\"chalk\")).default;\n        console.error(chalk.red(\"Failed to start server:\", err));\n        await shutdown();\n      });\n  }\n\n  private async handleFileChange(event: string, filePath: AbsolutePath): Promise<void> {\n    // 첫 번째 파일이면 HMR 시작 시간 기록\n    if (this.pendingFiles.length === 0) {\n      this.hmrStartTime = Date.now();\n    }\n    this.pendingFiles.push(filePath);\n\n    const relativePath = path.relative(this.apiRootPath, filePath);\n    const chalk = (await import(\"chalk\")).default;\n    console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));\n\n    await this.syncer.syncFromWatcher(event, filePath);\n\n    // 처리 완료된 파일을 대기 목록에서 제거\n    this.pendingFiles = this.pendingFiles.slice(1);\n\n    // 모든 파일 처리가 완료되면 최종 메시지 출력\n    if (this.pendingFiles.length === 0) {\n      await this.finishHMR();\n    }\n  }\n\n  private async finishHMR(): Promise<void> {\n    await this.syncer.renewChecksums();\n\n    const endTime = Date.now();\n    const totalTime = endTime - this.hmrStartTime;\n    const [chalk, { centerText }] = await Promise.all([\n      (await import(\"chalk\")).default,\n      import(\"../utils/console-util\"),\n    ]);\n    const msg = `HMR Done! ${chalk.bold.white(`${totalTime}ms`)}`;\n\n    console.log(chalk.black.bgGreen(centerText(msg)));\n  }\n\n  async destroy(): Promise<void> {\n    const { BaseModel } = await import(\"../database/base-model\");\n    await BaseModel.destroy();\n    await this._workflows?.destroy();\n    await this.watcher?.close();\n    this.storage?.destroy();\n  }\n}\nexport const Sonamu = new SonamuClass();\n"],"names":["assert","AsyncLocalStorage","os","path","createMockSSEFactory","DB","isDaemonServer","Naite","SonamuClass","isInitialized","asyncLocalStorage","uploadStorage","getContext","store","getStore","context","process","env","NODE_ENV","request","reply","headers","createSSE","schema","naiteStore","Map","Error","getUploadContext","uploadContext","_apiRootPath","apiRootPath","appRootPath","split","sep","slice","join","_dbConfig","dbConfig","_syncer","syncer","_config","config","_secrets","secrets","_storage","storage","_workflows","workflows","watcher","pendingFiles","hmrStartTime","server","initForTesting","init","undefined","doSilent","enableSync","forTesting","chalk","default","console","time","cyan","findApiRootPath","loadConfig","database","ANTHROPIC_API_KEY","anthropic_api_key","VOYAGE_API_KEY","voyage_api_key","OPENAI_API_KEY","openai_api_key","Object","keys","length","generateDBConfig","log","green","EntityManager","autoload","initializeWorkflows","tasks","Syncer","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","TemplateManager","isLocal","isTest","setupBiome","isHotReloadServer","sync","startWatcher","timeEnd","createServer","initOptions","options","fastify","plugins","registerPlugins","auth","session","registerAuth","withFastify","apiConfig","boot","timezone","api","formatInTimeZone","ISO_DATE_REGEX","DATE_FORMAT","setReplySerializer","payload","JSON","stringify","_key","value","test","Date","get","route","prefix","_request","_reply","apis","sonamuUIApiPlugin","register","all","url","startsWith","found","find","httpMethod","method","toUpperCase","createApiHandler","NotFoundException","models","modelName","handler","guards","every","guard","guardHandler","getZodObjectFromApi","ReqType","types","which","reqBody","fastifyCaster","parse","e","ZodError","humanizeZodError","messages","map","issue","message","BadRequestException","zodError","type","contentType","createContext","ApiParamType","args","parameters","param","isContext","name","invokeModelMethod","model","run","result","methodName","apply","createSSEFactory","_events","socket","bind","Promise","resolve","contextProvider","createStore","user","passport","login","logout","watchPath","chokidar","watch","ignored","stats","isFile","endsWith","persistent","ignoreInitial","on","event","filePath","absolutePath","isConfigTs","relativePath","replace","bold","blue","kill","pid","handleFileChange","error","runScript","fn","destroy","pluginsModules","cors","formbody","multipart","qs","sse","static","registerPlugin","key","pluginName","option","entries","custom","fastifyPassport","initialize","secureSession","registerUserSerializer","registerUserDeserializer","serialized","userSerializer","userDeserializer","WorkflowManager","getDBConfig","enableWorker","defaultWorkerOptions","concurrency","cpus","usePubSub","listenDelay","setupWorker","workerOptions","port","listen","host","addHook","lifecycle","onShutdown","shutdown","close","exit","err","onError","setErrorHandler","then","startWorker","onStart","catch","red","now","push","relative","syncFromWatcher","finishHMR","renewChecksums","endTime","totalTime","centerText","msg","white","black","bgGreen","BaseModel","Sonamu"],"mappings":"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"}

package/dist/syncer/checksum.d.ts

@@ -10,12 +10,17 @@ export declare function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]
  * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.
  */
 export declare function renewChecksums(): Promise<void>;
+export type FileOrData = {
+    path: PathLike;
+} | {
+    data: string;
+};
 /**
  * 두 파일의 내용이 같은지 체크섬으로 비교합니다.
  * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.
- * @param one 파일 경로
- * @param two 파일 경로
+ * @param one 파일 경로 혹은 데이터
+ * @param two 파일 경로 혹은 데이터
  * @returns boolean
  */
-export declare function areFilesSame(one: PathLike, two: PathLike): Promise<boolean>;
+export declare function areFilesSame(...files: FileOrData[]): Promise<boolean>;
 //# sourceMappingURL=checksum.d.ts.map

package/dist/syncer/checksum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,IAAI,CAAC;AAOrD,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,qBAAqB,CAAC;AASzE;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAU9E;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CASjF"}
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,IAAI,CAAC;AAOrD,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,qBAAqB,CAAC;AASzE;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAU9E;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD;AAED,MAAM,MAAM,UAAU,GAClB;IACE,IAAI,EAAE,QAAQ,CAAC;CAChB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,GAAG,KAAK,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAiB3E"}

package/dist/syncer/checksum.js

@@ -36,16 +36,19 @@ import { getChecksumPatternGroupInAbsolutePath } from "./file-patterns.js";
 /**
  * 두 파일의 내용이 같은지 체크섬으로 비교합니다.
  * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.
- * @param one 파일 경로
- * @param two 파일 경로
+ * @param one 파일 경로 혹은 데이터
+ * @param two 파일 경로 혹은 데이터
  * @returns boolean
- */ export async function areFilesSame(one, two) {
-    if (!await exists(one) || !await exists(two)) {
-        return false;
+ */ export async function areFilesSame(...files) {
+    const checksums = [];
+    for (const file of files){
+        if ("path" in file && !await exists(file.path)) {
+            return false;
+        }
+        checksums.push("path" in file ? await getChecksumOfFile(file.path) : getChecksumOfData(file.data));
     }
-    const oneChecksum = await getChecksumOfFile(one);
-    const twoChecksum = await getChecksumOfFile(two);
-    return oneChecksum === twoChecksum;
+    return checksums.every(// 다음 체크섬과 비교, 만약 마지막 체크섬일 때는 첫 번째 체크섬과 비교
+    (checksum, index)=>checksum === checksums[index === checksums.length - 1 ? 0 : index + 1]);
 }
 async function getCurrentChecksums() {
     const filePaths = (await Promise.all(Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern])=>{
@@ -81,6 +84,11 @@ async function saveChecksums(checksums) {
         })), null, 2), "utf-8");
     console.log("checksum saved", checksumFilePath);
 }
+function getChecksumOfData(data) {
+    const hash = crypto.createHash("sha1");
+    hash.update(data);
+    return hash.digest("hex");
+}
 async function getChecksumOfFile(filePath) {
     return new Promise((resolve, reject)=>{
         const hash = crypto.createHash("sha1");
@@ -95,4 +103,4 @@ async function getChecksumOfFile(filePath) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/checksum.ts"],"sourcesContent":["import crypto, { type BinaryLike } from \"crypto\";\nimport equal from \"fast-deep-equal\";\nimport { createReadStream, type PathLike } from \"fs\";\nimport { readFile, writeFile } from \"fs/promises\";\nimport path from \"path\";\nimport { isEqual } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport type { AbsolutePath, ApiRelativePath } from \"../utils/path-utils\";\nimport { differenceWith } from \"../utils/utils\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\n\ntype PathAndChecksum = {\n  path: AbsolutePath;\n  checksum: string;\n};\n\n/**\n * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.\n * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: \"/src/application/user/user.model.ts\"\n */\nexport async function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return [];\n  }\n\n  return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);\n}\n\n/**\n * 체크섬을 갱신합니다.\n * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.\n */\nexport async function renewChecksums(): Promise<void> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return;\n  }\n\n  await saveChecksums(calculatedChecksums);\n}\n\n/**\n * 두 파일의 내용이 같은지 체크섬으로 비교합니다.\n * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.\n * @param one 파일 경로\n * @param two 파일 경로\n * @returns boolean\n */\nexport async function areFilesSame(one: PathLike, two: PathLike): Promise<boolean> {\n  if (!(await exists(one)) || !(await exists(two))) {\n    return false;\n  }\n\n  const oneChecksum = await getChecksumOfFile(one);\n  const twoChecksum = await getChecksumOfFile(two);\n\n  return oneChecksum === twoChecksum;\n}\n\nasync function getCurrentChecksums(): Promise<PathAndChecksum[]> {\n  const filePaths = (\n    await Promise.all(\n      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {\n        return globAsync(pattern) as Promise<AbsolutePath[]>;\n      }),\n    )\n  )\n    .flat()\n    .sort();\n\n  const fileChecksums = await Promise.all(\n    filePaths.map(async (filePath) => {\n      return {\n        path: filePath,\n        checksum: await getChecksumOfFile(filePath),\n      };\n    }),\n  );\n\n  return fileChecksums;\n}\n\nasync function getPreviousChecksums(): Promise<PathAndChecksum[]> {\n  const checksumFilePath = getChecksumFilePath();\n  if (!(await exists(checksumFilePath))) {\n    return [];\n  }\n\n  const previousChecksums = JSON.parse(await readFile(checksumFilePath, \"utf-8\")).map(\n    (r: { path: ApiRelativePath; checksum: string }) => ({\n      path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로\n      checksum: r.checksum,\n    }),\n  ) as PathAndChecksum[];\n  return previousChecksums;\n}\n\nfunction getChecksumFilePath(): AbsolutePath {\n  return path.join(Sonamu.apiRootPath, \"sonamu.lock\") as AbsolutePath;\n}\n\nasync function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {\n  const checksumFilePath = getChecksumFilePath();\n  await writeFile(\n    checksumFilePath,\n    JSON.stringify(\n      checksums.map((r) => ({\n        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로\n        checksum: r.checksum,\n      })),\n      null,\n      2,\n    ),\n    \"utf-8\",\n  );\n  console.log(\"checksum saved\", checksumFilePath);\n}\n\nasync function getChecksumOfFile(filePath: PathLike): Promise<string> {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"sha1\");\n    const input = createReadStream(filePath);\n    input.on(\"error\", reject);\n    input.on(\"data\", (chunk: BinaryLike) => {\n      hash.update(chunk);\n    });\n    input.on(\"close\", () => {\n      resolve(hash.digest(\"hex\"));\n    });\n  });\n}\n"],"names":["crypto","equal","createReadStream","readFile","writeFile","path","isEqual","Sonamu","globAsync","exists","differenceWith","getChecksumPatternGroupInAbsolutePath","findChangedFilesUsingChecksums","calculatedChecksums","getCurrentChecksums","savedChecksums","getPreviousChecksums","isSame","map","r","renewChecksums","saveChecksums","areFilesSame","one","two","oneChecksum","getChecksumOfFile","twoChecksum","filePaths","Promise","all","Object","entries","_fileType","pattern","flat","sort","fileChecksums","filePath","checksum","checksumFilePath","getChecksumFilePath","previousChecksums","JSON","parse","join","apiRootPath","checksums","stringify","relative","console","log","resolve","reject","hash","createHash","input","on","chunk","update","digest"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/checksum.ts"],"sourcesContent":["import crypto, { type BinaryLike } from \"crypto\";\nimport equal from \"fast-deep-equal\";\nimport { createReadStream, type PathLike } from \"fs\";\nimport { readFile, writeFile } from \"fs/promises\";\nimport path from \"path\";\nimport { isEqual } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport type { AbsolutePath, ApiRelativePath } from \"../utils/path-utils\";\nimport { differenceWith } from \"../utils/utils\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\n\ntype PathAndChecksum = {\n  path: AbsolutePath;\n  checksum: string;\n};\n\n/**\n * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.\n * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: \"/src/application/user/user.model.ts\"\n */\nexport async function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return [];\n  }\n\n  return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);\n}\n\n/**\n * 체크섬을 갱신합니다.\n * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.\n */\nexport async function renewChecksums(): Promise<void> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return;\n  }\n\n  await saveChecksums(calculatedChecksums);\n}\n\nexport type FileOrData =\n  | {\n      path: PathLike;\n    }\n  | {\n      data: string;\n    };\n\n/**\n * 두 파일의 내용이 같은지 체크섬으로 비교합니다.\n * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.\n * @param one 파일 경로 혹은 데이터\n * @param two 파일 경로 혹은 데이터\n * @returns boolean\n */\nexport async function areFilesSame(...files: FileOrData[]): Promise<boolean> {\n  const checksums: string[] = [];\n\n  for (const file of files) {\n    if (\"path\" in file && !(await exists(file.path))) {\n      return false;\n    }\n\n    checksums.push(\n      \"path\" in file ? await getChecksumOfFile(file.path) : getChecksumOfData(file.data),\n    );\n  }\n\n  return checksums.every(\n    // 다음 체크섬과 비교, 만약 마지막 체크섬일 때는 첫 번째 체크섬과 비교\n    (checksum, index) => checksum === checksums[index === checksums.length - 1 ? 0 : index + 1],\n  );\n}\n\nasync function getCurrentChecksums(): Promise<PathAndChecksum[]> {\n  const filePaths = (\n    await Promise.all(\n      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {\n        return globAsync(pattern) as Promise<AbsolutePath[]>;\n      }),\n    )\n  )\n    .flat()\n    .sort();\n\n  const fileChecksums = await Promise.all(\n    filePaths.map(async (filePath) => {\n      return {\n        path: filePath,\n        checksum: await getChecksumOfFile(filePath),\n      };\n    }),\n  );\n\n  return fileChecksums;\n}\n\nasync function getPreviousChecksums(): Promise<PathAndChecksum[]> {\n  const checksumFilePath = getChecksumFilePath();\n  if (!(await exists(checksumFilePath))) {\n    return [];\n  }\n\n  const previousChecksums = JSON.parse(await readFile(checksumFilePath, \"utf-8\")).map(\n    (r: { path: ApiRelativePath; checksum: string }) => ({\n      path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로\n      checksum: r.checksum,\n    }),\n  ) as PathAndChecksum[];\n  return previousChecksums;\n}\n\nfunction getChecksumFilePath(): AbsolutePath {\n  return path.join(Sonamu.apiRootPath, \"sonamu.lock\") as AbsolutePath;\n}\n\nasync function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {\n  const checksumFilePath = getChecksumFilePath();\n  await writeFile(\n    checksumFilePath,\n    JSON.stringify(\n      checksums.map((r) => ({\n        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로\n        checksum: r.checksum,\n      })),\n      null,\n      2,\n    ),\n    \"utf-8\",\n  );\n  console.log(\"checksum saved\", checksumFilePath);\n}\n\nfunction getChecksumOfData(data: string): string {\n  const hash = crypto.createHash(\"sha1\");\n  hash.update(data);\n  return hash.digest(\"hex\");\n}\n\nasync function getChecksumOfFile(filePath: PathLike): Promise<string> {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"sha1\");\n    const input = createReadStream(filePath);\n    input.on(\"error\", reject);\n    input.on(\"data\", (chunk: BinaryLike) => {\n      hash.update(chunk);\n    });\n    input.on(\"close\", () => {\n      resolve(hash.digest(\"hex\"));\n    });\n  });\n}\n"],"names":["crypto","equal","createReadStream","readFile","writeFile","path","isEqual","Sonamu","globAsync","exists","differenceWith","getChecksumPatternGroupInAbsolutePath","findChangedFilesUsingChecksums","calculatedChecksums","getCurrentChecksums","savedChecksums","getPreviousChecksums","isSame","map","r","renewChecksums","saveChecksums","areFilesSame","files","checksums","file","push","getChecksumOfFile","getChecksumOfData","data","every","checksum","index","length","filePaths","Promise","all","Object","entries","_fileType","pattern","flat","sort","fileChecksums","filePath","checksumFilePath","getChecksumFilePath","previousChecksums","JSON","parse","join","apiRootPath","stringify","relative","console","log","hash","createHash","update","digest","resolve","reject","input","on","chunk"],"mappings":"AAAA,OAAOA,YAAiC,SAAS;AACjD,OAAOC,WAAW,kBAAkB;AACpC,SAASC,gBAAgB,QAAuB,KAAK;AACrD,SAASC,QAAQ,EAAEC,SAAS,QAAQ,mBAAc;AAClD,OAAOC,UAAU,OAAO;AACxB,SAASC,OAAO,QAAQ,UAAU;AAClC,SAASC,MAAM,QAAQ,mBAAgB;AACvC,SAASC,SAAS,QAAQ,0BAAuB;AACjD,SAASC,MAAM,QAAQ,uBAAoB;AAE3C,SAASC,cAAc,QAAQ,oBAAiB;AAChD,SAASC,qCAAqC,QAAQ,qBAAkB;AAOxE;;;CAGC,GACD,OAAO,eAAeC;IACpB,MAAMC,sBAAsB,MAAMC;IAClC,MAAMC,iBAAiB,MAAMC;IAE7B,MAAMC,SAAShB,MAAMY,qBAAqBE;IAC1C,IAAIE,QAAQ;QACV,OAAO,EAAE;IACX;IAEA,OAAOP,eAAeG,qBAAqBE,gBAAgBT,SAASY,GAAG,CAAC,CAACC,IAAMA,EAAEd,IAAI;AACvF;AAEA;;;CAGC,GACD,OAAO,eAAee;IACpB,MAAMP,sBAAsB,MAAMC;IAClC,MAAMC,iBAAiB,MAAMC;IAE7B,MAAMC,SAAShB,MAAMY,qBAAqBE;IAC1C,IAAIE,QAAQ;QACV;IACF;IAEA,MAAMI,cAAcR;AACtB;AAUA;;;;;;CAMC,GACD,OAAO,eAAeS,aAAa,GAAGC,KAAmB;IACvD,MAAMC,YAAsB,EAAE;IAE9B,KAAK,MAAMC,QAAQF,MAAO;QACxB,IAAI,UAAUE,QAAQ,CAAE,MAAMhB,OAAOgB,KAAKpB,IAAI,GAAI;YAChD,OAAO;QACT;QAEAmB,UAAUE,IAAI,CACZ,UAAUD,OAAO,MAAME,kBAAkBF,KAAKpB,IAAI,IAAIuB,kBAAkBH,KAAKI,IAAI;IAErF;IAEA,OAAOL,UAAUM,KAAK,CACpB,0CAA0C;IAC1C,CAACC,UAAUC,QAAUD,aAAaP,SAAS,CAACQ,UAAUR,UAAUS,MAAM,GAAG,IAAI,IAAID,QAAQ,EAAE;AAE/F;AAEA,eAAelB;IACb,MAAMoB,YAAY,AAChB,CAAA,MAAMC,QAAQC,GAAG,CACfC,OAAOC,OAAO,CAAC3B,yCAAyCO,GAAG,CAAC,OAAO,CAACqB,WAAWC,QAAQ;QACrF,OAAOhC,UAAUgC;IACnB,GACF,EAECC,IAAI,GACJC,IAAI;IAEP,MAAMC,gBAAgB,MAAMR,QAAQC,GAAG,CACrCF,UAAUhB,GAAG,CAAC,OAAO0B;QACnB,OAAO;YACLvC,MAAMuC;YACNb,UAAU,MAAMJ,kBAAkBiB;QACpC;IACF;IAGF,OAAOD;AACT;AAEA,eAAe3B;IACb,MAAM6B,mBAAmBC;IACzB,IAAI,CAAE,MAAMrC,OAAOoC,mBAAoB;QACrC,OAAO,EAAE;IACX;IAEA,MAAME,oBAAoBC,KAAKC,KAAK,CAAC,MAAM9C,SAAS0C,kBAAkB,UAAU3B,GAAG,CACjF,CAACC,IAAoD,CAAA;YACnDd,MAAMA,KAAK6C,IAAI,CAAC3C,OAAO4C,WAAW,EAAEhC,EAAEd,IAAI;YAC1C0B,UAAUZ,EAAEY,QAAQ;QACtB,CAAA;IAEF,OAAOgB;AACT;AAEA,SAASD;IACP,OAAOzC,KAAK6C,IAAI,CAAC3C,OAAO4C,WAAW,EAAE;AACvC;AAEA,eAAe9B,cAAcG,SAA4B;IACvD,MAAMqB,mBAAmBC;IACzB,MAAM1C,UACJyC,kBACAG,KAAKI,SAAS,CACZ5B,UAAUN,GAAG,CAAC,CAACC,IAAO,CAAA;YACpBd,MAAMA,KAAKgD,QAAQ,CAAC9C,OAAO4C,WAAW,EAAEhC,EAAEd,IAAI;YAC9C0B,UAAUZ,EAAEY,QAAQ;QACtB,CAAA,IACA,MACA,IAEF;IAEFuB,QAAQC,GAAG,CAAC,kBAAkBV;AAChC;AAEA,SAASjB,kBAAkBC,IAAY;IACrC,MAAM2B,OAAOxD,OAAOyD,UAAU,CAAC;IAC/BD,KAAKE,MAAM,CAAC7B;IACZ,OAAO2B,KAAKG,MAAM,CAAC;AACrB;AAEA,eAAehC,kBAAkBiB,QAAkB;IACjD,OAAO,IAAIT,QAAgB,CAACyB,SAASC;QACnC,MAAML,OAAOxD,OAAOyD,UAAU,CAAC;QAC/B,MAAMK,QAAQ5D,iBAAiB0C;QAC/BkB,MAAMC,EAAE,CAAC,SAASF;QAClBC,MAAMC,EAAE,CAAC,QAAQ,CAACC;YAChBR,KAAKE,MAAM,CAACM;QACd;QACAF,MAAMC,EAAE,CAAC,SAAS;YAChBH,QAAQJ,KAAKG,MAAM,CAAC;QACtB;IACF;AACF"}

package/dist/syncer/code-generator.js

@@ -87,7 +87,12 @@ async function resolveRenderedTemplate(key, result) {
     const { target, path: filePath, body, importKeys, customHeaders } = result;
     // import 할 대상의 대상 path 추출
     const importDefs = importKeys.reduce((r, importKey)=>{
-        const modulePath = EntityManager.getModulePath(importKey);
+        let modulePath = importKey;
+        try {
+            modulePath = EntityManager.getModulePath(importKey);
+        } catch (error) {
+            throw new Error(`[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`);
+        }
         let importPath = modulePath;
         if (modulePath.includes("/") || modulePath.includes(".")) {
             importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p)=>[
@@ -158,4 +163,4 @@ async function writeCodeToPathEachTarget(pathAndCode) {
     }));
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\nimport { unique } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport type { RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport type { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite === true) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(\"이미 경로에 모든 파일이 존재합니다.\");\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const importDefs = importKeys\n    .reduce(\n      (r, importKey) => {\n        const modulePath = EntityManager.getModulePath(importKey);\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            p.startsWith(\".\") === false,\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`) === false);\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = formatCode(\n        [header, body].join(\"\\n\\n\"),\n        key === \"entity\" ? \"json\" : \"typescript\",\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"names":["chalk","mkdir","writeFile","path","unique","Sonamu","EntityManager","AlreadyProcessedException","Naite","TemplateManager","everyAsync","filterAsync","isTest","formatCode","exists","wrapIf","generateTemplate","key","templateOptions","_generateOptions","generateOptions","overwrite","t","keys","pathAndCodes","Promise","all","map","renderTemplate","flat","filteredPathAndCodes","pathAndCode","targets","config","sync","filePath","appRootPath","dstFilePaths","target","replace","dstPath","length","writeCodeToPathEachTarget","options","template","get","rendered","render","resolved","resolveRenderedTemplate","preTemplateResolved","preTemplates","result","body","importKeys","customHeaders","importDefs","reduce","r","importKey","modulePath","getModulePath","importPath","includes","relative","dirname","p","startsWith","existsOne","find","importDef","from","concat","push","filter","endsWith","header","join","formatted","code","dstFilePath","dir","recursive","console","log","bold","blue"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\nimport { unique } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport type { RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport type { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite === true) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(\"이미 경로에 모든 파일이 존재합니다.\");\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const importDefs = importKeys\n    .reduce(\n      (r, importKey) => {\n        let modulePath = importKey;\n        try {\n          modulePath = EntityManager.getModulePath(importKey);\n        } catch (error) {\n          throw new Error(\n            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,\n          );\n        }\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            p.startsWith(\".\") === false,\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`) === false);\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = formatCode(\n        [header, body].join(\"\\n\\n\"),\n        key === \"entity\" ? \"json\" : \"typescript\",\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"names":["chalk","mkdir","writeFile","path","unique","Sonamu","EntityManager","AlreadyProcessedException","Naite","TemplateManager","everyAsync","filterAsync","isTest","formatCode","exists","wrapIf","generateTemplate","key","templateOptions","_generateOptions","generateOptions","overwrite","t","keys","pathAndCodes","Promise","all","map","renderTemplate","flat","filteredPathAndCodes","pathAndCode","targets","config","sync","filePath","appRootPath","dstFilePaths","target","replace","dstPath","length","writeCodeToPathEachTarget","options","template","get","rendered","render","resolved","resolveRenderedTemplate","preTemplateResolved","preTemplates","result","body","importKeys","customHeaders","importDefs","reduce","r","importKey","modulePath","getModulePath","error","Error","importPath","includes","relative","dirname","p","startsWith","existsOne","find","importDef","from","concat","push","filter","endsWith","header","join","formatted","code","dstFilePath","dir","recursive","console","log","bold","blue"],"mappings":"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"}

package/dist/syncer/syncer.d.ts

@@ -52,18 +52,18 @@ export declare class Syncer {
     handleModelOrFrameChange(diffGroups: DiffGroups): Promise<void>;
     actionSyncConfig(): Promise<void>;
     /**
-     * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.
-     * @returns 생성된 파일 경로 배열.
-     */
-    actionGenerateSchemas(): Promise<AbsolutePath[]>;
-    /**
-     * *.service.ts를 생성합니다.
+     * services.generated.ts를 생성합니다.
      * @param paramsArray
      * @returns 생성된 파일 경로 배열.
      */
     actionGenerateServices(paramsArray: {
         namesRecord: EntityNamesRecord;
     }[]): Promise<string[]>;
+    /**
+     * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.
+     * @returns 생성된 파일 경로 배열.
+     */
+    actionGenerateSchemas(): Promise<AbsolutePath[]>;
     /**
      * sonamu.generated.http를 생성합니다.
      * @returns 생성된 파일 경로.