sonamu 0.5.7 → 0.7.0

package/src/api/sonamu.ts

@@ -1,56 +1,22 @@
+import assert from "assert";
 import { AsyncLocalStorage } from "async_hooks";
-import chalk from "chalk";
-import fastify from "fastify";
-import { readFile } from "fs/promises";
-import path from "path";
-import { exists } from "../utils/fs-utils";
-
 import type { FSWatcher } from "chokidar";
-import { formatInTimeZone } from "date-fns-tz";
 import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
 import type { IncomingMessage, Server, ServerResponse } from "http";
-import { ZodError, ZodObject } from "zod";
-import { DB, SonamuDBConfig } from "../database/db";
-import { attachOnDuplicateUpdate } from "../database/knex-plugins/knex-on-duplicate-update";
-import {
-  BadRequestException,
-  NotFoundException,
-} from "../exceptions/so-exceptions";
+import path from "path";
+import type { ZodObject } from "zod";
+import type { SonamuDBConfig } from "../database/db";
 import type { Driver } from "../file-storage/driver";
-import { createSSEFactory } from "../stream/sse";
+import { Naite } from "../naite/naite";
 import type { Syncer } from "../syncer/syncer";
-import {
-  ApiParamType,
-  SonamuFastifyConfig,
-  SonamuServerOptions,
-} from "../types/types";
-import { isLocal, isTest } from "../utils/controller";
-import { findApiRootPath } from "../utils/utils";
-import { humanizeZodError } from "../utils/zod-error";
-import { fastifyCaster } from "./caster";
-import { getZodObjectFromApi } from "./code-converters";
+import type { SonamuFastifyConfig } from "../types/types";
+import type { AbsolutePath } from "../utils/path-utils";
+import type { SonamuConfig, SonamuServerOptions } from "./config";
 import type { AuthContext, Context, UploadContext } from "./context";
 import type { ExtendedApi } from "./decorators";
-import fastifyPassport from "@fastify/passport";
-
-export type SonamuConfig = {
-  projectName?: string;
-  api: {
-    dir: string;
-  };
-  sync: {
-    targets: string[];
-  };
-  route: {
-    prefix: string;
-  };
-  timezone?: string;
-  ui?: {
-    port: number;
-  };
-};
+
 export type SonamuSecrets = {
-  [key: string]: string;
+  anthropic_api_key?: string;
 };
 class SonamuClass {
   public isInitialized: boolean = false;
@@ -67,7 +33,20 @@ class SonamuClass {
     if (store?.context) {
       return store.context;
     }
-    throw new Error("Sonamu cannot find context");
+
+    if (process.env.NODE_ENV === "test") {
+      // 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴
+      return {
+        request: null,
+        reply: null,
+        headers: {},
+        createSSE: () => {},
+        // biome-ignore lint/suspicious/noExplicitAny: 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴
+        naiteStore: new Map<string, any>(),
+      } as unknown as Context;
+    } else {
+      throw new Error("Sonamu cannot find context");
+    }
   }
 
   public getUploadContext(): UploadContext {
@@ -75,20 +54,18 @@ class SonamuClass {
     if (store?.uploadContext) {
       return store.uploadContext;
     }
-    throw new Error(
-      "Sonamu cannot find upload context. Did you use @upload decorator?"
-    );
+    throw new Error("Sonamu cannot find upload context. Did you use @upload decorator?");
   }
 
-  private _apiRootPath: string | null = null;
-  set apiRootPath(apiRootPath: string) {
+  private _apiRootPath: AbsolutePath | null = null;
+  set apiRootPath(apiRootPath: AbsolutePath) {
     this._apiRootPath = apiRootPath;
   }
-  get apiRootPath(): string {
+  get apiRootPath(): AbsolutePath {
     if (this._apiRootPath === null) {
       throw new Error("Sonamu has not been initialized");
     }
-    return this._apiRootPath!;
+    return this._apiRootPath;
   }
   get appRootPath(): string {
     return this.apiRootPath.split(path.sep).slice(0, -1).join(path.sep);
@@ -102,7 +79,7 @@ class SonamuClass {
     if (this._dbConfig === null) {
       throw new Error("Sonamu has not been initialized");
     }
-    return this._dbConfig!;
+    return this._dbConfig;
   }
 
   private _syncer: Syncer | null = null;
@@ -113,7 +90,7 @@ class SonamuClass {
     if (this._syncer === null) {
       throw new Error("Sonamu has not been initialized");
     }
-    return this._syncer!;
+    return this._syncer;
   }
 
   private _config: SonamuConfig | null = null;
@@ -157,37 +134,40 @@ class SonamuClass {
   async init(
     doSilent: boolean = false,
     enableSync: boolean = true,
-    apiRootPath?: string,
-    forTesting: boolean = false
+    apiRootPath?: AbsolutePath,
+    forTesting: boolean = false,
   ) {
     if (this.isInitialized) {
       return;
     }
-    !doSilent &&
-      console.time(
-        chalk.cyan(`Sonamu.init${forTesting ? " for testing" : ""}`)
-      );
+
+    if (!doSilent) {
+      const chalk = (await import("chalk")).default;
+      console.time(chalk.cyan(`Sonamu.init${forTesting ? " for testing" : ""}`));
+    }
 
     // API 루트 패스
+    const { findApiRootPath } = await import("../utils/utils");
     this.apiRootPath = apiRootPath ?? findApiRootPath();
-    const configPath = path.join(this.apiRootPath, "sonamu.config.json");
-    const secretsPath = path.join(this.apiRootPath, "sonamu.secrets.json");
-    if (!(await exists(configPath))) {
-      throw new Error(`Cannot find sonamu.config.json in ${configPath}`);
-    }
-    this.config = JSON.parse(
-      (await readFile(configPath)).toString()
-    ) as SonamuConfig;
-    if (await exists(secretsPath)) {
-      this.secrets = JSON.parse(
-        (await readFile(secretsPath)).toString()
-      ) as SonamuSecrets;
+
+    const { loadConfig } = await import("./config");
+    this.config = await loadConfig(this.apiRootPath);
+    // sonamu.config.ts 기본값 설정
+    this.config.database.database = this.config.database.database ?? "postgresql";
+
+    if (process.env.ANTHROPIC_API_KEY) {
+      this.secrets = {
+        anthropic_api_key: process.env.ANTHROPIC_API_KEY,
+      };
     }
 
     // DB 로드
-    this.dbConfig = await DB.readKnexfile();
-    !doSilent && console.log(chalk.green("DB Config Loaded!"));
-    attachOnDuplicateUpdate();
+    const { DB } = await import("../database/db");
+    this.dbConfig = DB.generateDBConfig(this.config.database);
+    if (!doSilent) {
+      const chalk = (await import("chalk")).default;
+      console.log(chalk.green("DB Config Loaded!"));
+    }
 
     // 테스팅인 경우 엔티티 로드 & 싱크 없이 중단
     if (forTesting) {
@@ -204,30 +184,42 @@ class SonamuClass {
     this.syncer = new Syncer();
 
     // Autoload: Models / Types / APIs
-    await this.syncer.autoloadModels();
     await this.syncer.autoloadTypes();
+    await this.syncer.autoloadModels();
     await this.syncer.autoloadApis();
 
-    if (isLocal() && !isTest() && enableSync) {
+    const { TemplateManager } = await import("../template");
+    await TemplateManager.autoload();
+
+    const { isLocal, isTest } = await import("../utils/controller");
+    if (isLocal()) {
+      // 로컬에서는 코드 생성을 위해 Biome 셋업이 필요함 (현재 apiRootPath 전달하여 실행)
+      (await import("../utils/formatter")).setupBiome(this.apiRootPath);
+    }
+
+    const { isHotReloadServer } = await import("../utils/controller");
+    if (isLocal() && !isTest() && isHotReloadServer() && enableSync) {
       await this.syncer.sync();
 
-      // FIXME: hmr 설정된 경우만 워처 시작
-      this.startWatcher();
+      await this.startWatcher();
 
       this.syncer.syncUI();
     }
 
     this.isInitialized = true;
-    !doSilent && console.timeEnd(chalk.cyan("Sonamu.init"));
+    if (!doSilent) {
+      const chalk = (await import("chalk")).default;
+      console.timeEnd(chalk.cyan("Sonamu.init"));
+    }
   }
 
-  async createServer(
-    options: SonamuServerOptions,
-    initOptions?: {
-      enableSync?: boolean;
-      doSilent?: boolean;
+  async createServer(initOptions?: { enableSync?: boolean; doSilent?: boolean }) {
+    if (this.isInitialized === false) {
+      await this.init(initOptions?.doSilent, initOptions?.enableSync);
     }
-  ) {
+
+    const options = this.config.server;
+    const fastify = (await import("fastify")).default;
     const server = fastify(options.fastify);
     this.server = server;
 
@@ -238,17 +230,15 @@ class SonamuClass {
 
     // 플러그인 등록
     if (options.plugins) {
-      this.registerPlugins(server, options.plugins);
+      await this.registerPlugins(server, options.plugins);
     }
 
     if (options.auth) {
       if (!options.plugins?.session) {
-        throw new Error(
-          "Auth requires session plugin. Please add plugins.session configuration."
-        );
+        throw new Error("Auth requires session plugin. Please add plugins.session configuration.");
       }
 
-      this.registerAuth(server, options.auth);
+      await this.registerAuth(server, options.auth);
     }
 
     // API 라우팅 설정
@@ -269,7 +259,7 @@ class SonamuClass {
     options?: {
       enableSync?: boolean;
       doSilent?: boolean;
-    }
+    },
   ) {
     if (this.isInitialized === false) {
       await this.init(options?.doSilent, options?.enableSync);
@@ -278,55 +268,72 @@ class SonamuClass {
     this.server = server;
 
     // timezone 설정
-    const timezone = this.config.timezone;
+    const timezone = this.config.api.timezone;
     if (timezone) {
-      const DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ssXXX";
+      // 타임존에 맞게 응답 날짜 스트링을 변환해주어야 합니다.
+      // 가령 timezone이 "Asia/Seoul" 이면
+      // "2025-11-21T00:00:00.000Z" 를 "2025-11-21T09:00:00+09:00" 으로 변환해주어야 합니다.
+      const { formatInTimeZone } = await import("date-fns-tz");
+
       // ISO 8601 날짜 형식 정규식 (예: 2024-01-15T09:30:00.000Z)
       const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
 
+      // T를 둘러싼 작은따옴표가 없다면 "2025-11-19176354618900018:56:29+09:00"와 같은 결과가 나옵니다.
+      // 이는 date-fns 특입니다.
+      // 이렇게 해도 괜찮습니다. "2025-11-19T18:56:29+09:00" 모양으로 잘 나옵니다.
+      const DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ssXXX";
+
       server.setReplySerializer((payload) => {
         return JSON.stringify(payload, (_key, value) => {
           if (typeof value === "string" && ISO_DATE_REGEX.test(value)) {
-            return formatInTimeZone(new Date(value), timezone, DATE_FORMAT);
+            return formatInTimeZone(
+              new Date(value),
+              timezone as `${string}/${string}`,
+              DATE_FORMAT,
+            );
           }
           return value;
         });
       });
-      !options?.doSilent &&
+      if (!options?.doSilent) {
+        const chalk = (await import("chalk")).default;
         console.log(chalk.green(`Timezone set to ${timezone}`));
+      }
     }
 
     // 전체 라우팅 리스트
     server.get(
-      `${this.config.route.prefix}/routes`,
-      async (_request, _reply): Promise<any> => {
+      `${this.config.api.route.prefix}/routes`,
+      async (_request, _reply): Promise<typeof this.syncer.apis> => {
         return this.syncer.apis;
-      }
+      },
     );
 
     // Healthcheck API
     server.get(
-      `${this.config.route.prefix}/healthcheck`,
+      `${this.config.api.route.prefix}/healthcheck`,
       async (_request, _reply): Promise<string> => {
         return "ok";
-      }
+      },
     );
 
     // API 라우팅 (로컬HMR 상태와 구분)
+    const { isLocal } = await import("../utils/controller");
     if (isLocal()) {
-      server.all("*", (request, reply) => {
+      server.all("*", async (request, reply) => {
         const found = this.syncer.apis.find(
           (api) =>
-            this.config.route.prefix + api.path === request.url.split("?")[0] &&
-            (api.options.httpMethod ?? "GET") === request.method.toUpperCase()
+            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);
         }
+        const { NotFoundException } = await import("../exceptions/so-exceptions");
         throw new NotFoundException("존재하지 않는 API 접근입니다.");
       });
     } else {
-      this.syncer.apis.map((api) => {
+      for (const api of this.syncer.apis) {
         // model
         if (this.syncer.models[api.modelName] === undefined) {
           throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);
@@ -334,24 +341,23 @@ class SonamuClass {
 
         // route
         server.route({
-          method: api.options.httpMethod!,
-          url: this.config.route.prefix + api.path,
+          method: api.options.httpMethod ?? "GET",
+          url: this.config.api.route.prefix + api.path,
           handler: this.getApiHandler(api, config),
         }); // END server.route
-      });
+      }
     }
   }
 
-  getApiHandler(api: ExtendedApi, config: SonamuFastifyConfig) {
-    return async (
-      request: FastifyRequest,
-      reply: FastifyReply
-    ): Promise<unknown> => {
-      (api.options.guards ?? []).every((guard) =>
-        config.guardHandler(guard, request, api)
-      );
+  getApiHandler(
+    api: ExtendedApi,
+    config: SonamuFastifyConfig,
+  ): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown> {
+    return async (request: FastifyRequest, reply: FastifyReply): Promise<unknown> => {
+      (api.options.guards ?? []).every((guard) => config.guardHandler(guard, request, api));
 
       // 파라미터 정보로 zod 스키마 빌드
+      const { getZodObjectFromApi } = await import("./code-converters");
       const ReqType = getZodObjectFromApi(api, this.syncer.types);
 
       // request 파싱
@@ -360,12 +366,16 @@ class SonamuClass {
         [key: string]: unknown;
       };
       try {
+        const { fastifyCaster } = await import("./caster");
         reqBody = fastifyCaster(ReqType).parse(request[which] ?? {});
       } catch (e) {
+        const { ZodError } = await import("zod");
         if (e instanceof ZodError) {
+          const { humanizeZodError } = await import("../utils/zod-error");
           const messages = humanizeZodError(e)
             .map((issue) => issue.message)
             .join(" ");
+          const { BadRequestException } = await import("../exceptions/so-exceptions");
           throw new BadRequestException(messages, {
             zodError: e,
           });
@@ -402,15 +412,12 @@ class SonamuClass {
       }
 
       // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.
+      const { createSSEFactory } = await import("../stream/sse");
       const createSSE = (<T extends ZodObject>(
         _request: FastifyRequest,
         _reply: FastifyReply,
-        _events: T
-      ) => createSSEFactory(_request.socket, _reply, _events)).bind(
-        null,
-        request,
-        reply
-      );
+        _events: T,
+      ) => createSSEFactory(_request.socket, _reply, _events)).bind(null, request, reply);
 
       const context: Context = {
         ...(await Promise.resolve(
@@ -420,25 +427,24 @@ class SonamuClass {
               reply,
               headers: request.headers,
               createSSE,
+              naiteStore: Naite.createStore(),
               // auth
               user: request.user ?? null,
               passport: {
-                login: request.login.bind(
-                  request
-                ) as AuthContext["passport"]["login"],
-                logout: request.logout.bind(
-                  request
-                ) as AuthContext["passport"]["logout"],
+                login: request.login.bind(request) as AuthContext["passport"]["login"],
+                logout: request.logout.bind(request) as AuthContext["passport"]["logout"],
               },
             },
             request,
-            reply
-          )
+            reply,
+          ),
         )),
       };
 
       const model = this.syncer.models[api.modelName];
       return this.asyncLocalStorage.run({ context }, async () => {
+        const { ApiParamType } = await import("../types/types");
+        // biome-ignore lint/suspicious/noExplicitAny: model은 모델 인스턴스이므로 메서드 호출 가능
         const result = await (model as any)[api.methodName].apply(
           model,
           api.parameters.map((param) => {
@@ -448,7 +454,7 @@ class SonamuClass {
             } else {
               return reqBody[param.name];
             }
-          })
+          }),
         );
         reply.type(api.options.contentType ?? "application/json");
 
@@ -461,25 +467,46 @@ class SonamuClass {
     };
   }
 
-  startWatcher(): void {
-    const watchPath = path.join(this.apiRootPath, "src");
-    const chokidar = require("chokidar") as typeof import("chokidar");
+  async startWatcher(): Promise<void> {
+    const watchPath = [
+      path.join(this.apiRootPath, "src"),
+      path.join(this.apiRootPath, "sonamu.config.ts"),
+    ];
+
+    const chokidar = (await import("chokidar")).default;
     this.watcher = chokidar.watch(watchPath, {
       ignored: (path, stats) =>
-        (!!stats?.isFile() &&
-          !path.endsWith(".ts") &&
-          !path.endsWith(".json")) ||
-        path.endsWith("src/index.ts"),
+        !!stats?.isFile() && !path.endsWith(".ts") && !path.endsWith(".json"),
       persistent: true,
       ignoreInitial: true,
     });
+
     this.watcher.on("all", async (event: string, filePath: string) => {
+      const absolutePath = filePath as AbsolutePath;
+      assert(
+        absolutePath.startsWith(this.apiRootPath),
+        "File path is not within the API root path",
+      );
+
       if (event !== "change" && event !== "add") {
         return;
       }
 
       try {
-        await this.handleFileChange(event, filePath);
+        // sonamu.config.ts 변경 시 재시작
+        const isConfigTs = filePath === path.join(this.apiRootPath, "sonamu.config.ts");
+
+        if (isConfigTs) {
+          const relativePath = filePath.replace(this.apiRootPath, "api");
+          const chalk = (await import("chalk")).default;
+          console.log(
+            chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`),
+          );
+          process.kill(process.pid, "SIGUSR2");
+          return;
+        }
+
+        await this.handleFileChange(event, absolutePath);
       } catch (e) {
         console.error(e);
       }
@@ -498,10 +525,7 @@ class SonamuClass {
     }
   }
 
-  private registerPlugins(
-    server: FastifyInstance,
-    plugins: SonamuServerOptions["plugins"]
-  ) {
+  private async registerPlugins(server: FastifyInstance, plugins: SonamuServerOptions["plugins"]) {
     if (!plugins) {
       return;
     }
@@ -516,23 +540,23 @@ class SonamuClass {
       session: "@fastify/secure-session",
     } as const;
 
-    const registerPlugin = <K extends keyof NonNullable<typeof plugins>>(
+    const registerPlugin = async <K extends keyof NonNullable<typeof plugins>>(
       key: K,
-      pluginName: string
+      pluginName: string,
     ) => {
       const option = plugins[key];
       if (!option) return;
 
       if (option === true) {
-        server.register(import(pluginName));
+        server.register((await import(pluginName)).default);
       } else {
-        server.register(import(pluginName), option);
+        server.register((await import(pluginName)).default, option);
       }
     };
 
-    Object.entries(pluginsModules).forEach(([key, pluginName]) => {
-      registerPlugin(key as keyof typeof plugins, pluginName);
-    });
+    for (const [key, pluginName] of Object.entries(pluginsModules)) {
+      await registerPlugin(key as keyof typeof plugins, pluginName);
+    }
 
     if (plugins.custom) {
       plugins.custom(server);
@@ -541,16 +565,16 @@ class SonamuClass {
 
   private async registerAuth(
     server: FastifyInstance,
-    options: NonNullable<SonamuServerOptions["auth"]>
+    options: NonNullable<SonamuServerOptions["auth"]>,
   ) {
+    // await import("fastify");
+    const fastifyPassport = (await import("@fastify/passport")).default;
     server.register(fastifyPassport.initialize());
     server.register(fastifyPassport.secureSession());
 
     if (typeof options === "boolean") {
       fastifyPassport.registerUserSerializer(async (user, _request) => user);
-      fastifyPassport.registerUserDeserializer(
-        async (serialized, _request) => serialized
-      );
+      fastifyPassport.registerUserDeserializer(async (serialized, _request) => serialized);
     } else {
       fastifyPassport.registerUserSerializer(options.userSerializer);
       fastifyPassport.registerUserDeserializer(options.userDeserializer);
@@ -589,26 +613,24 @@ class SonamuClass {
         await options.lifecycle?.onStart?.(server);
       })
       .catch(async (err) => {
+        const chalk = (await import("chalk")).default;
         console.error(chalk.red("Failed to start server:", err));
         await shutdown();
       });
   }
 
-  private async handleFileChange(
-    event: string,
-    filePath: string
-  ): Promise<void> {
+  private async handleFileChange(event: string, filePath: AbsolutePath): Promise<void> {
     // 첫 번째 파일이면 HMR 시작 시간 기록
     if (this.pendingFiles.length === 0) {
       this.hmrStartTime = Date.now();
     }
-
     this.pendingFiles.push(filePath);
 
-    const relativePath = filePath.replace(this.apiRootPath, "api");
+    const relativePath = path.relative(this.apiRootPath, filePath);
+    const chalk = (await import("chalk")).default;
     console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));
 
-    await this.syncer.syncFromWatcher([filePath]);
+    await this.syncer.syncFromWatcher(event, filePath);
 
     // 처리 완료된 파일을 대기 목록에서 제거
     this.pendingFiles = this.pendingFiles.slice(1);
@@ -620,20 +642,21 @@ class SonamuClass {
   }
 
   private async finishHMR(): Promise<void> {
-    await this.syncer.saveChecksums(await this.syncer.getCurrentChecksums());
+    await this.syncer.renewChecksums();
 
     const endTime = Date.now();
     const totalTime = endTime - this.hmrStartTime;
+    const [chalk, { centerText }] = await Promise.all([
+      (await import("chalk")).default,
+      import("../utils/console-util"),
+    ]);
     const msg = `HMR Done! ${chalk.bold.white(`${totalTime}ms`)}`;
-    const margin = Math.max(0, (process.stdout.columns - msg.length) / 2);
 
-    console.log(
-      chalk.black.bgGreen(" ".repeat(margin) + msg + " ".repeat(margin))
-    );
+    console.log(chalk.black.bgGreen(centerText(msg)));
   }
 
   async destroy(): Promise<void> {
-    const { BaseModel } = require("../database/base-model");
+    const { BaseModel } = await import("../database/base-model");
     await BaseModel.destroy();
     await this.watcher?.close();
     this.storage?.destroy();