sonamu 0.7.21 → 0.7.23

package/dist/api/sonamu.js

@@ -1,9 +1,12 @@
+import { dispose as logtapeDispose } from "@logtape/logtape";
 import assert from "assert";
 import { AsyncLocalStorage } from "async_hooks";
+import fs from "fs";
 import os from "os";
 import path from "path";
 import { createMockSSEFactory, DB, isDaemonServer } from "../index.js";
 import { Naite } from "../naite/naite.js";
+import { getSecrets } from "./secret.js";
 class SonamuClass {
     isInitialized = false;
     asyncLocalStorage = new AsyncLocalStorage();
@@ -77,13 +80,7 @@ class SonamuClass {
         }
         return this._config;
     }
-    _secrets = null;
-    set secrets(secrets) {
-        this._secrets = secrets;
-    }
-    get secrets() {
-        return this._secrets;
-    }
+    secrets = getSecrets();
     _storage = null;
     /**
    * StorageManager 인스턴스
@@ -93,6 +90,15 @@ class SonamuClass {
         }
         return this._storage;
     }
+    _cache = null;
+    /**
+   * CacheManager 인스턴스 (BentoCache)
+   */ get cache() {
+        if (!this._cache) {
+            throw new Error("Cache has not been initialized. Check cache config in sonamu.config.ts.");
+        }
+        return this._cache;
+    }
     _workflows = null;
     get workflows() {
         if (this._workflows === null) {
@@ -119,23 +125,18 @@ class SonamuClass {
         // API 루트 패스
         const { findApiRootPath } = await import("../utils/utils.js");
         this.apiRootPath = apiRootPath ?? findApiRootPath();
+        // 설정을 로딩하는 것부터 시작
         const { loadConfig } = await import("./config.js");
         this.config = await loadConfig(this.apiRootPath);
         // sonamu.config.ts 기본값 설정
-        this.config.database.database = this.config.database.database ?? "postgresql";
-        // API 키 환경변수 로드
-        const secrets = {};
-        if (process.env.ANTHROPIC_API_KEY) {
-            secrets.anthropic_api_key = process.env.ANTHROPIC_API_KEY;
-        }
-        if (process.env.VOYAGE_API_KEY) {
-            secrets.voyage_api_key = process.env.VOYAGE_API_KEY;
-        }
-        if (process.env.OPENAI_API_KEY) {
-            secrets.openai_api_key = process.env.OPENAI_API_KEY;
-        }
-        if (Object.keys(secrets).length > 0) {
-            this.secrets = secrets;
+        this.config.database.database = this.config.database.database ?? "pg";
+        this.config.database.defaultOptions.client = this.config.database.database ?? "pg";
+        // 로깅 설정
+        const { configureLogTape } = await import("../logger/configure.js");
+        if (this.config.logging !== false) {
+            await configureLogTape({
+                ...this.config.logging
+            });
         }
         // DB 로드
         const { DB } = await import("../database/db.js");
@@ -149,6 +150,8 @@ class SonamuClass {
         // upsert가 제대로 작동하려면 entity의 unique index 정보가 필요하기 때문입니다.
         const { EntityManager } = await import("../entity/entity-manager.js");
         await EntityManager.autoload(doSilent);
+        // Cache 초기화
+        await this.initializeCache(this.config.server.cache, forTesting);
         // 테스팅인 경우 싱크 없이 중단
         if (forTesting) {
             this.isInitialized = true;
@@ -159,13 +162,14 @@ class SonamuClass {
         // Syncer
         const { Syncer } = await import("../syncer/syncer.js");
         this.syncer = new Syncer();
-        // Autoload: Models / Types / APIs
+        // Autoload: Models / Types / APIs / Workflows / Templates / SSR Routes
         await this.syncer.autoloadTypes();
         await this.syncer.autoloadModels();
         await this.syncer.autoloadApis();
         await this.syncer.autoloadWorkflows();
         const { TemplateManager } = await import("../template/index.js");
         await TemplateManager.autoload();
+        await this.syncer.autoloadSSRRoutes();
         const { isLocal, isTest } = await import("../utils/controller.js");
         if (isLocal()) {
             // 로컬에서는 코드 생성을 위해 Biome 셋업이 필요함 (현재 apiRootPath 전달하여 실행)
@@ -187,8 +191,16 @@ class SonamuClass {
             await this.init(initOptions?.doSilent, initOptions?.enableSync);
         }
         const options = this.config.server;
-        const fastify = (await import("fastify")).default;
-        const server = fastify(options.fastify);
+        const { default: fastify } = await import("fastify");
+        const { getLogTapeFastifyLogger } = await import("@logtape/fastify");
+        const server = fastify({
+            ...options.fastify,
+            logger: this.config.logging !== false ? getLogTapeFastifyLogger({
+                category: this.config.logging?.fastifyCategory ?? [
+                    "fastify"
+                ]
+            }) : undefined
+        });
         this.server = server;
         // Storage 설정 → StorageManager 생성
         if (options.storage) {
@@ -256,39 +268,202 @@ class SonamuClass {
         // Sonamu UI API
         const { sonamuUIApiPlugin } = await import("../ui/api.js");
         server.register(sonamuUIApiPlugin);
-        // API 라우팅 (로컬HMR 상태와 구분)
+        // 로컬/프로덕션 환경 분기
         const { isLocal } = await import("../utils/controller.js");
+        const webPath = path.join(this.appRootPath, "web");
+        const hasWeb = fs.existsSync(webPath);
         if (isLocal()) {
-            server.all("*", async (request, reply)=>{
-                // Sonamu UI
-                if (request.url.startsWith("/sonamu-ui")) {
-                    return;
-                }
-                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.createApiHandler(found, config)(request, reply);
-                }
-                if (request.url.startsWith("/api/")) {
-                    const { NotFoundException } = await import("../exceptions/so-exceptions.js");
-                    throw new NotFoundException(`존재하지 않는 API 접근입니다. ${request.url}`);
-                }
-                // 일반 파일 접근시 별도의 에러 출력하지 않음
-                return;
-            });
+            // 로컬 개발 환경: Vite Dev Server + 통합 핸들러
+            if (hasWeb) {
+                await this.setupViteDevServer(server, webPath, config);
+            }
         } else {
+            // 프로덕션 환경: 개별 API 라우트 + 정적 파일 서빙
             for (const api of this.syncer.apis){
-                // model
                 if (this.syncer.models[api.modelName] === undefined) {
                     throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);
                 }
-                // route
                 server.route({
                     method: api.options.httpMethod ?? "GET",
                     url: this.config.api.route.prefix + api.path,
                     handler: this.createApiHandler(api, config)
-                }); // END server.route
+                });
+            }
+            if (hasWeb) {
+                await this.setupStaticWebServer(server, webPath, config);
+            }
+        }
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: ViteDevServer 타입을 동적으로 로드해야 함
+    viteServer = null;
+    async setupViteDevServer(server, webPath, config) {
+        // @fastify/middie 등록 (Connect-style middleware 지원)
+        await server.register((await import("@fastify/middie")).default);
+        const vite = await import("vite");
+        this.viteServer = await vite.createServer({
+            root: webPath,
+            server: {
+                middlewareMode: true,
+                hmr: {
+                    server: server.server
+                }
+            },
+            appType: "custom"
+        });
+        // Vite middleware 등록 (Vite 에셋 처리)
+        server.use((req, res, next)=>{
+            // API와 Sonamu UI는 Fastify 라우트가 처리하도록 skip
+            if (req.url?.startsWith(this.config.api.route.prefix) || req.url?.startsWith("/sonamu-ui")) {
+                return next();
+            }
+            // 나머지는 Vite middleware로 전달
+            return this.viteServer.middlewares(req, res, next);
+        });
+        // API 동적 라우팅 (catch-all 전에 등록)
+        for (const api of this.syncer.apis){
+            if (this.syncer.models[api.modelName] === undefined) {
+                throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);
+            }
+            server.route({
+                method: api.options.httpMethod ?? "GET",
+                url: this.config.api.route.prefix + api.path,
+                handler: this.createApiHandler(api, config)
+            });
+        }
+        // Catch-all 핸들러: SSR + CSR fallback
+        server.setNotFoundHandler(async (request, reply)=>{
+            const url = request.url;
+            // SSR 라우트 체크
+            const { matchSSRRoute } = await import("../ssr/index.js");
+            const match = matchSSRRoute(url);
+            if (match) {
+                console.log(`[SSR] Matched route: ${match.route.path}`);
+                // SSR 렌더링
+                try {
+                    const { renderSSR } = await import("../ssr/index.js");
+                    const html = await renderSSR(url, match.route, match.params, request, reply, config, this.viteServer);
+                    reply.type("text/html").send(html);
+                    return;
+                } catch (e) {
+                    console.error("SSR Error:", e);
+                    console.log("Falling back to CSR...");
+                // fallback to CSR (아래 로직 실행)
+                }
+            }
+            // CSR fallback
+            try {
+                const fs = await import("node:fs/promises");
+                let template = await fs.readFile(path.join(this.viteServer.config.root, "index.html"), "utf-8");
+                template = await this.viteServer.transformIndexHtml(url, template);
+                reply.type("text/html").send(template);
+                return;
+            } catch (e) {
+                this.viteServer.ssrFixStacktrace(e);
+                console.error(e);
+                reply.status(500).send(e.message);
+                return;
             }
+        });
+        // 서버 종료 시 Vite도 종료
+        server.addHook("onClose", async ()=>{
+            await this.viteServer.close();
+        });
+        console.log("✓ Vite dev server integrated");
+    }
+    async setupStaticWebServer(server, _webPath, config) {
+        // 경로 명확화: api/public/web, api/dist/ssr
+        const webDistPath = path.join(this.apiRootPath, "public", "web");
+        const ssrPath = path.join(this.apiRootPath, "dist", "ssr");
+        if (!fs.existsSync(webDistPath)) {
+            console.warn(`⚠ Web dist not found: ${webDistPath}`);
+            return;
         }
+        // SSR entry 존재 여부 확인
+        const ssrEntryPath = path.join(ssrPath, "entry-server.generated.js");
+        const ssrAvailable = fs.existsSync(ssrEntryPath);
+        if (!ssrAvailable) {
+            console.warn(`⚠ SSR entry not found: ${ssrEntryPath}`);
+            console.warn("  SSR will be disabled. Only CSR will work.");
+        }
+        // SSR 라우트 로드 (production에서만, 사용자 프로젝트의 ssr/routes.ts)
+        if (ssrAvailable) {
+            const ssrRoutesPath = path.join(this.apiRootPath, "dist", "ssr", "routes.js");
+            if (fs.existsSync(ssrRoutesPath)) {
+                await import(ssrRoutesPath);
+                console.log("✓ SSR routes loaded");
+            } else {
+                console.warn(`⚠ SSR routes not found: ${ssrRoutesPath}`);
+            }
+        }
+        // 롤링 업데이트 대응: asset hash 불일치 시 현재 버전 직접 서빙
+        server.get("/assets/:filename", async (request, reply)=>{
+            const requestedFile = request.params.filename;
+            const assetsDir = path.join(webDistPath, "assets");
+            // index-*.js 또는 index-*.css 요청인 경우
+            if (/^index-[a-f0-9]+\.(js|css)$/.test(requestedFile)) {
+                const ext = requestedFile.split(".").pop();
+                const files = fs.readdirSync(assetsDir);
+                const currentFile = files.find((f)=>f.startsWith("index-") && f.endsWith(`.${ext}`));
+                if (currentFile) {
+                    const filePath = path.join(assetsDir, currentFile);
+                    const content = fs.readFileSync(filePath);
+                    reply.type(ext === "js" ? "application/javascript" : "text/css");
+                    reply.header("Cache-Control", "public, max-age=31536000, immutable");
+                    return reply.send(content);
+                }
+            }
+            // 일반 파일 서빙
+            const filePath = path.join(assetsDir, requestedFile);
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath);
+                const ext = requestedFile.split(".").pop();
+                reply.type(ext === "js" ? "application/javascript" : ext === "css" ? "text/css" : "");
+                if (requestedFile.includes("-")) {
+                    reply.header("Cache-Control", "public, max-age=31536000, immutable");
+                }
+                return reply.send(content);
+            }
+            reply.code(404).send("Not found");
+        });
+        // SPA/SSR 라우팅
+        server.setNotFoundHandler(async (request, reply)=>{
+            // /api, /sonamu-ui는 404 그대로
+            if (request.url.startsWith("/api") || request.url.startsWith("/sonamu-ui")) {
+                reply.code(404).send({
+                    error: "Not Found"
+                });
+                return;
+            }
+            const url = request.url;
+            // SSR 라우트 체크
+            if (ssrAvailable) {
+                const { matchSSRRoute } = await import("../ssr/index.js");
+                const match = matchSSRRoute(url);
+                if (match) {
+                    try {
+                        // renderSSR 재사용 (vite 없이 호출 = production 모드)
+                        const { renderSSR } = await import("../ssr/renderer.js");
+                        const html = await renderSSR(url, match.route, match.params, request, reply, config);
+                        reply.type("text/html").send(html);
+                        console.log(`[SSR] Matched route: ${match.route.path}`);
+                        return;
+                    } catch (e) {
+                        console.error("[SSR Error]", {
+                            url: request.url,
+                            route: match.route.path,
+                            error: e instanceof Error ? e.message : String(e),
+                            timestamp: new Date().toISOString()
+                        });
+                    // CSR로 fallback
+                    }
+                }
+            }
+            // CSR fallback (SSR 실패 시 또는 SSR 라우트가 아닌 경우)
+            const indexPath = path.join(webDistPath, "index.html");
+            const html = fs.readFileSync(indexPath, "utf-8");
+            reply.type("text/html").send(html);
+        });
+        console.log(`✓ Static web server configured with ${ssrAvailable ? "SSR" : "CSR only"} support`);
     }
     createApiHandler(api, config) {
         return async (request, reply)=>{
@@ -332,6 +507,25 @@ class SonamuClass {
             return this.invokeModelMethod(api, args, context, reply);
         };
     }
+    /**
+   * SSR용 API 호출 (HTTP 오버헤드 없이 직접 호출)
+   * createApiHandler의 로직을 재사용하되, request 파싱 대신 params 직접 사용
+   */ async invokeApiForSSR(api, // biome-ignore lint/suspicious/noExplicitAny: SSR에서 다양한 타입의 params를 받아야 함
+    params, config, request, reply) {
+        // Context 생성 (기존 메소드 재사용)
+        const context = await this.createContext(config, request, reply);
+        // args 생성: Context 파라미터는 주입, 나머지는 params에서 가져오기
+        const { ApiParamType } = await import("../types/types.js");
+        let paramsIndex = 0;
+        const args = api.parameters.map((param)=>{
+            if (ApiParamType.isContext(param.type)) {
+                return context;
+            }
+            return params[paramsIndex++];
+        });
+        // 모델 메서드 호출 (기존 메서드 재사용)
+        return this.invokeModelMethod(api, args, context, reply);
+    }
     async invokeModelMethod(api, args, context, reply) {
         const model = this.syncer.models[api.modelName];
         return this.asyncLocalStorage.run({
@@ -448,6 +642,25 @@ class SonamuClass {
             fastifyPassport.registerUserDeserializer(options.userDeserializer);
         }
     }
+    async initializeCache(config, forTesting) {
+        const { setCacheManagerRef } = await import("../cache/decorator.js");
+        // 테스트 환경에서 메모리 드라이버 자동 사용
+        if (forTesting) {
+            const { createTestCacheManager } = await import("../cache/cache-manager.js");
+            this._cache = createTestCacheManager();
+            setCacheManagerRef(this._cache);
+            return;
+        }
+        // 설정이 없으면 캐시 비활성화
+        if (!config) {
+            setCacheManagerRef(null);
+            return;
+        }
+        // 설정에 따라 CacheManager 생성
+        const { createCacheManager } = await import("../cache/cache-manager.js");
+        this._cache = createCacheManager(config);
+        setCacheManagerRef(this._cache);
+    }
     async initializeWorkflows(options) {
         const { WorkflowManager } = await import("../tasks/workflow-manager.js");
         // NOTE: @sonamu-kit/tasks 안에선 knex config를 수정하기 때문에 connection이 아닌 config 째로 보냅니다.
@@ -532,11 +745,16 @@ class SonamuClass {
     }
     async destroy() {
         const { BaseModel } = await import("../database/base-model.js");
+        // 먼저 처리해야함.
         await BaseModel.destroy();
-        await this._workflows?.destroy();
-        await this.watcher?.close();
+        await Promise.allSettled([
+            this._workflows?.destroy() ?? Promise.resolve(),
+            this._cache?.disconnect() ?? Promise.resolve(),
+            this.watcher?.close() ?? Promise.resolve(),
+            logtapeDispose()
+        ]);
     }
 }
 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 { Naite } from \"../naite/naite\";\nimport type { StorageManager } from \"../storage/storage-manager\";\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: StorageManager | null = null;\n  /**\n   * StorageManager 인스턴스\n   */\n  get storage(): StorageManager {\n    if (!this._storage) {\n      throw new Error(\"Storage has not been initialized. Check storage config.\");\n    }\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 설정 → StorageManager 생성\n    if (options.storage) {\n      const { StorageManager } = await import(\"../storage/storage-manager\");\n      this._storage = new StorageManager(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  }\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","StorageManager","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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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/sonamu.ts"],"sourcesContent":["import { dispose as logtapeDispose } from \"@logtape/logtape\";\nimport assert from \"assert\";\nimport { AsyncLocalStorage } from \"async_hooks\";\nimport type { FSWatcher } from \"chokidar\";\nimport type { FastifyInstance, FastifyReply, FastifyRequest } from \"fastify\";\nimport fs from \"fs\";\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 { CacheConfig, CacheManager } from \"../cache/types\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport { Naite } from \"../naite/naite\";\nimport type { StorageManager } from \"../storage/storage-manager\";\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\";\nimport { getSecrets, type SonamuSecrets } from \"./secret\";\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  public readonly secrets: SonamuSecrets = getSecrets();\n\n  private _storage: StorageManager | null = null;\n  /**\n   * StorageManager 인스턴스\n   */\n  get storage(): StorageManager {\n    if (!this._storage) {\n      throw new Error(\"Storage has not been initialized. Check storage config.\");\n    }\n    return this._storage;\n  }\n\n  private _cache: CacheManager | null = null;\n  /**\n   * CacheManager 인스턴스 (BentoCache)\n   */\n  get cache(): CacheManager {\n    if (!this._cache) {\n      throw new Error(\"Cache has not been initialized. Check cache config in sonamu.config.ts.\");\n    }\n    return this._cache;\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    // 설정을 로딩하는 것부터 시작\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 ?? \"pg\";\n    this.config.database.defaultOptions.client = this.config.database.database ?? \"pg\";\n\n    // 로깅 설정\n    const { configureLogTape } = await import(\"../logger/configure\");\n    if (this.config.logging !== false) {\n      await configureLogTape({\n        ...this.config.logging,\n      });\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    // Cache 초기화\n    await this.initializeCache(this.config.server.cache, forTesting);\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 / Workflows / Templates / SSR Routes\n    await this.syncer.autoloadTypes();\n    await this.syncer.autoloadModels();\n    await this.syncer.autoloadApis();\n    await this.syncer.autoloadWorkflows();\n    const { TemplateManager } = await import(\"../template\");\n    await TemplateManager.autoload();\n    await this.syncer.autoloadSSRRoutes();\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      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 { default: fastify } = await import(\"fastify\");\n    const { getLogTapeFastifyLogger } = await import(\"@logtape/fastify\");\n    const server = fastify({\n      ...options.fastify,\n      logger:\n        this.config.logging !== false\n          ? getLogTapeFastifyLogger({\n              category: this.config.logging?.fastifyCategory ?? [\"fastify\"],\n            })\n          : undefined,\n    });\n    this.server = server;\n\n    // Storage 설정 → StorageManager 생성\n    if (options.storage) {\n      const { StorageManager } = await import(\"../storage/storage-manager\");\n      this._storage = new StorageManager(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    // 로컬/프로덕션 환경 분기\n    const { isLocal } = await import(\"../utils/controller\");\n    const webPath = path.join(this.appRootPath, \"web\");\n    const hasWeb = fs.existsSync(webPath);\n\n    if (isLocal()) {\n      // 로컬 개발 환경: Vite Dev Server + 통합 핸들러\n      if (hasWeb) {\n        await this.setupViteDevServer(server, webPath, config);\n      }\n    } else {\n      // 프로덕션 환경: 개별 API 라우트 + 정적 파일 서빙\n      for (const api of this.syncer.apis) {\n        if (this.syncer.models[api.modelName] === undefined) {\n          throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);\n        }\n\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        });\n      }\n\n      if (hasWeb) {\n        await this.setupStaticWebServer(server, webPath, config);\n      }\n    }\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: ViteDevServer 타입을 동적으로 로드해야 함\n  private viteServer: any = null;\n\n  private async setupViteDevServer(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    webPath: string,\n    config: SonamuFastifyConfig,\n  ): Promise<void> {\n    // @fastify/middie 등록 (Connect-style middleware 지원)\n    await server.register((await import(\"@fastify/middie\")).default);\n\n    const vite = await import(\"vite\");\n\n    this.viteServer = await vite.createServer({\n      root: webPath,\n      server: {\n        middlewareMode: true,\n        hmr: {\n          server: server.server,\n        },\n      },\n      appType: \"custom\",\n    });\n\n    // Vite middleware 등록 (Vite 에셋 처리)\n    server.use((req, res, next) => {\n      // API와 Sonamu UI는 Fastify 라우트가 처리하도록 skip\n      if (req.url?.startsWith(this.config.api.route.prefix) || req.url?.startsWith(\"/sonamu-ui\")) {\n        return next();\n      }\n      // 나머지는 Vite middleware로 전달\n      return this.viteServer.middlewares(req, res, next);\n    });\n\n    // API 동적 라우팅 (catch-all 전에 등록)\n    for (const api of this.syncer.apis) {\n      if (this.syncer.models[api.modelName] === undefined) {\n        throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);\n      }\n\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      });\n    }\n\n    // Catch-all 핸들러: SSR + CSR fallback\n    server.setNotFoundHandler(async (request, reply) => {\n      const url = request.url;\n\n      // SSR 라우트 체크\n      const { matchSSRRoute } = await import(\"../ssr\");\n      const match = matchSSRRoute(url);\n\n      if (match) {\n        console.log(`[SSR] Matched route: ${match.route.path}`);\n        // SSR 렌더링\n        try {\n          const { renderSSR } = await import(\"../ssr\");\n          const html = await renderSSR(\n            url,\n            match.route,\n            match.params,\n            request,\n            reply,\n            config,\n            this.viteServer,\n          );\n          reply.type(\"text/html\").send(html);\n          return;\n        } catch (e) {\n          console.error(\"SSR Error:\", e);\n          console.log(\"Falling back to CSR...\");\n          // fallback to CSR (아래 로직 실행)\n        }\n      }\n\n      // CSR fallback\n      try {\n        const fs = await import(\"node:fs/promises\");\n        let template = await fs.readFile(\n          path.join(this.viteServer.config.root, \"index.html\"),\n          \"utf-8\",\n        );\n        template = await this.viteServer.transformIndexHtml(url, template);\n\n        reply.type(\"text/html\").send(template);\n        return;\n      } catch (e) {\n        this.viteServer.ssrFixStacktrace(e as Error);\n        console.error(e);\n        reply.status(500).send((e as Error).message);\n        return;\n      }\n    });\n\n    // 서버 종료 시 Vite도 종료\n    server.addHook(\"onClose\", async () => {\n      await this.viteServer.close();\n    });\n\n    console.log(\"✓ Vite dev server integrated\");\n  }\n\n  private async setupStaticWebServer(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    _webPath: string,\n    config: SonamuFastifyConfig,\n  ): Promise<void> {\n    // 경로 명확화: api/public/web, api/dist/ssr\n    const webDistPath = path.join(this.apiRootPath, \"public\", \"web\");\n    const ssrPath = path.join(this.apiRootPath, \"dist\", \"ssr\");\n\n    if (!fs.existsSync(webDistPath)) {\n      console.warn(`⚠ Web dist not found: ${webDistPath}`);\n      return;\n    }\n\n    // SSR entry 존재 여부 확인\n    const ssrEntryPath = path.join(ssrPath, \"entry-server.generated.js\");\n    const ssrAvailable = fs.existsSync(ssrEntryPath);\n\n    if (!ssrAvailable) {\n      console.warn(`⚠ SSR entry not found: ${ssrEntryPath}`);\n      console.warn(\"  SSR will be disabled. Only CSR will work.\");\n    }\n\n    // SSR 라우트 로드 (production에서만, 사용자 프로젝트의 ssr/routes.ts)\n    if (ssrAvailable) {\n      const ssrRoutesPath = path.join(this.apiRootPath, \"dist\", \"ssr\", \"routes.js\");\n      if (fs.existsSync(ssrRoutesPath)) {\n        await import(ssrRoutesPath);\n        console.log(\"✓ SSR routes loaded\");\n      } else {\n        console.warn(`⚠ SSR routes not found: ${ssrRoutesPath}`);\n      }\n    }\n\n    // 롤링 업데이트 대응: asset hash 불일치 시 현재 버전 직접 서빙\n    server.get(\"/assets/:filename\", async (request, reply) => {\n      const requestedFile = (request.params as { filename: string }).filename;\n      const assetsDir = path.join(webDistPath, \"assets\");\n\n      // index-*.js 또는 index-*.css 요청인 경우\n      if (/^index-[a-f0-9]+\\.(js|css)$/.test(requestedFile)) {\n        const ext = requestedFile.split(\".\").pop();\n        const files = fs.readdirSync(assetsDir);\n        const currentFile = files.find((f) => f.startsWith(\"index-\") && f.endsWith(`.${ext}`));\n\n        if (currentFile) {\n          const filePath = path.join(assetsDir, currentFile);\n          const content = fs.readFileSync(filePath);\n          reply.type(ext === \"js\" ? \"application/javascript\" : \"text/css\");\n          reply.header(\"Cache-Control\", \"public, max-age=31536000, immutable\");\n          return reply.send(content);\n        }\n      }\n\n      // 일반 파일 서빙\n      const filePath = path.join(assetsDir, requestedFile);\n      if (fs.existsSync(filePath)) {\n        const content = fs.readFileSync(filePath);\n        const ext = requestedFile.split(\".\").pop();\n        reply.type(ext === \"js\" ? \"application/javascript\" : ext === \"css\" ? \"text/css\" : \"\");\n        if (requestedFile.includes(\"-\")) {\n          reply.header(\"Cache-Control\", \"public, max-age=31536000, immutable\");\n        }\n        return reply.send(content);\n      }\n\n      reply.code(404).send(\"Not found\");\n    });\n\n    // SPA/SSR 라우팅\n    server.setNotFoundHandler(async (request, reply) => {\n      // /api, /sonamu-ui는 404 그대로\n      if (request.url.startsWith(\"/api\") || request.url.startsWith(\"/sonamu-ui\")) {\n        reply.code(404).send({ error: \"Not Found\" });\n        return;\n      }\n\n      const url = request.url;\n\n      // SSR 라우트 체크\n      if (ssrAvailable) {\n        const { matchSSRRoute } = await import(\"../ssr\");\n        const match = matchSSRRoute(url);\n\n        if (match) {\n          try {\n            // renderSSR 재사용 (vite 없이 호출 = production 모드)\n            const { renderSSR } = await import(\"../ssr/renderer\");\n            const html = await renderSSR(url, match.route, match.params, request, reply, config);\n            reply.type(\"text/html\").send(html);\n            console.log(`[SSR] Matched route: ${match.route.path}`);\n            return;\n          } catch (e) {\n            console.error(\"[SSR Error]\", {\n              url: request.url,\n              route: match.route.path,\n              error: e instanceof Error ? e.message : String(e),\n              timestamp: new Date().toISOString(),\n            });\n            // CSR로 fallback\n          }\n        }\n      }\n\n      // CSR fallback (SSR 실패 시 또는 SSR 라우트가 아닌 경우)\n      const indexPath = path.join(webDistPath, \"index.html\");\n      const html = fs.readFileSync(indexPath, \"utf-8\");\n      reply.type(\"text/html\").send(html);\n    });\n\n    console.log(`✓ Static web server configured with ${ssrAvailable ? \"SSR\" : \"CSR only\"} support`);\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  /**\n   * SSR용 API 호출 (HTTP 오버헤드 없이 직접 호출)\n   * createApiHandler의 로직을 재사용하되, request 파싱 대신 params 직접 사용\n   */\n  async invokeApiForSSR(\n    api: ExtendedApi,\n    // biome-ignore lint/suspicious/noExplicitAny: SSR에서 다양한 타입의 params를 받아야 함\n    params: any[],\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ): Promise<unknown> {\n    // Context 생성 (기존 메소드 재사용)\n    const context = await this.createContext(config, request, reply);\n\n    // args 생성: Context 파라미터는 주입, 나머지는 params에서 가져오기\n    const { ApiParamType } = await import(\"../types/types\");\n    let paramsIndex = 0;\n    const args = api.parameters.map((param) => {\n      if (ApiParamType.isContext(param.type)) {\n        return context;\n      }\n      return params[paramsIndex++];\n    });\n\n    // 모델 메서드 호출 (기존 메서드 재사용)\n    return this.invokeModelMethod(api, args, context, reply);\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 initializeCache(config: CacheConfig | undefined, forTesting: boolean) {\n    const { setCacheManagerRef } = await import(\"../cache/decorator\");\n\n    // 테스트 환경에서 메모리 드라이버 자동 사용\n    if (forTesting) {\n      const { createTestCacheManager } = await import(\"../cache/cache-manager\");\n      this._cache = createTestCacheManager();\n      setCacheManagerRef(this._cache);\n      return;\n    }\n\n    // 설정이 없으면 캐시 비활성화\n    if (!config) {\n      setCacheManagerRef(null);\n      return;\n    }\n\n    // 설정에 따라 CacheManager 생성\n    const { createCacheManager } = await import(\"../cache/cache-manager\");\n    this._cache = createCacheManager(config);\n    setCacheManagerRef(this._cache);\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    // 먼저 처리해야함.\n    await BaseModel.destroy();\n    await Promise.allSettled([\n      this._workflows?.destroy() ?? Promise.resolve(),\n      this._cache?.disconnect() ?? Promise.resolve(),\n      this.watcher?.close() ?? Promise.resolve(),\n      logtapeDispose(),\n    ]);\n  }\n}\n\nexport const Sonamu = new SonamuClass();\n"],"names":["dispose","logtapeDispose","assert","AsyncLocalStorage","fs","os","path","createMockSSEFactory","DB","isDaemonServer","Naite","getSecrets","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","_storage","storage","_cache","cache","_workflows","workflows","watcher","pendingFiles","hmrStartTime","server","initForTesting","init","undefined","doSilent","enableSync","forTesting","chalk","default","console","time","cyan","findApiRootPath","loadConfig","database","defaultOptions","client","configureLogTape","logging","generateDBConfig","log","green","EntityManager","autoload","initializeCache","initializeWorkflows","tasks","Syncer","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","TemplateManager","autoloadSSRRoutes","isLocal","isTest","setupBiome","isHotReloadServer","sync","startWatcher","timeEnd","createServer","initOptions","options","fastify","getLogTapeFastifyLogger","logger","category","fastifyCategory","StorageManager","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","webPath","hasWeb","existsSync","setupViteDevServer","models","modelName","method","httpMethod","url","handler","createApiHandler","setupStaticWebServer","viteServer","vite","root","middlewareMode","hmr","appType","use","req","res","next","startsWith","middlewares","setNotFoundHandler","matchSSRRoute","match","renderSSR","html","params","type","send","e","error","template","readFile","transformIndexHtml","ssrFixStacktrace","status","message","addHook","close","_webPath","webDistPath","ssrPath","warn","ssrEntryPath","ssrAvailable","ssrRoutesPath","requestedFile","filename","assetsDir","ext","pop","files","readdirSync","currentFile","find","f","endsWith","filePath","content","readFileSync","header","includes","code","String","timestamp","toISOString","indexPath","guards","every","guard","guardHandler","getZodObjectFromApi","ReqType","types","which","reqBody","fastifyCaster","parse","ZodError","humanizeZodError","messages","map","issue","BadRequestException","zodError","contentType","createContext","ApiParamType","args","parameters","param","isContext","name","invokeModelMethod","invokeApiForSSR","paramsIndex","model","run","result","methodName","apply","createSSEFactory","_events","socket","bind","Promise","resolve","contextProvider","createStore","user","passport","login","logout","watchPath","chokidar","watch","ignored","stats","isFile","persistent","ignoreInitial","on","event","absolutePath","isConfigTs","relativePath","replace","bold","blue","kill","pid","handleFileChange","runScript","fn","destroy","pluginsModules","cors","formbody","multipart","qs","sse","static","registerPlugin","key","pluginName","option","Object","entries","custom","fastifyPassport","initialize","secureSession","registerUserSerializer","registerUserDeserializer","serialized","userSerializer","userDeserializer","setCacheManagerRef","createTestCacheManager","createCacheManager","WorkflowManager","getDBConfig","enableWorker","defaultWorkerOptions","concurrency","cpus","length","usePubSub","listenDelay","setupWorker","workerOptions","port","listen","host","lifecycle","onShutdown","shutdown","exit","err","onError","setErrorHandler","then","startWorker","onStart","catch","red","now","push","relative","syncFromWatcher","finishHMR","renewChecksums","endTime","totalTime","centerText","all","msg","white","black","bgGreen","BaseModel","allSettled","disconnect","Sonamu"],"mappings":"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"}