sonamu 0.6.0 → 0.7.0

package/src/api/sonamu.ts

@@ -1,42 +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 chokidar, { type FSWatcher } from "chokidar";
-import { formatInTimeZone } from "date-fns-tz";
+import type { FSWatcher } from "chokidar";
 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 } 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";
-import { loadConfig, SonamuConfig, SonamuServerOptions } from "./config";
-import { AbsolutePath } from "../utils/path-utils";
-import { isHotReloadServer } from "../utils/esm-utils";
-import { Template } from "../template";
-import assert from "assert";
-import { centerText } from "../utils/console-util";
-import { BaseModel } from "../database/base-model";
 
 export type SonamuSecrets = {
-  [key: string]: string;
+  anthropic_api_key?: string;
 };
 class SonamuClass {
   public isInitialized: boolean = false;
@@ -61,6 +41,7 @@ class SonamuClass {
         reply: null,
         headers: {},
         createSSE: () => {},
+        // biome-ignore lint/suspicious/noExplicitAny: 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴
         naiteStore: new Map<string, any>(),
       } as unknown as Context;
     } else {
@@ -73,9 +54,7 @@ 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: AbsolutePath | null = null;
@@ -86,7 +65,7 @@ class SonamuClass {
     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);
@@ -100,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;
@@ -111,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;
@@ -156,30 +135,39 @@ class SonamuClass {
     doSilent: boolean = false,
     enableSync: boolean = true,
     apiRootPath?: AbsolutePath,
-    forTesting: boolean = false
+    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 { loadConfig } = await import("./config");
     this.config = await loadConfig(this.apiRootPath);
-    const secretsPath = path.join(this.apiRootPath, "sonamu.secrets.json");
-    if (await exists(secretsPath)) {
-      this.secrets = JSON.parse(
-        (await readFile(secretsPath)).toString()
-      ) as SonamuSecrets;
+    // 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 로드
+    const { DB } = await import("../database/db");
     this.dbConfig = DB.generateDBConfig(this.config.database);
-    !doSilent && console.log(chalk.green("DB Config Loaded!"));
-    attachOnDuplicateUpdate();
+    if (!doSilent) {
+      const chalk = (await import("chalk")).default;
+      console.log(chalk.green("DB Config Loaded!"));
+    }
 
     // 테스팅인 경우 엔티티 로드 & 싱크 없이 중단
     if (forTesting) {
@@ -200,29 +188,38 @@ class SonamuClass {
     await this.syncer.autoloadModels();
     await this.syncer.autoloadApis();
 
-    await Template.autoload();
+    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();
 
-      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(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;
 
@@ -233,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 라우팅 설정
@@ -264,7 +259,7 @@ class SonamuClass {
     options?: {
       enableSync?: boolean;
       doSilent?: boolean;
-    }
+    },
   ) {
     if (this.isInitialized === false) {
       await this.init(options?.doSilent, options?.enableSync);
@@ -275,28 +270,43 @@ class SonamuClass {
     // 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.api.route.prefix}/routes`,
-      async (_request, _reply): Promise<any> => {
+      async (_request, _reply): Promise<typeof this.syncer.apis> => {
         return this.syncer.apis;
-      }
+      },
     );
 
     // Healthcheck API
@@ -304,25 +314,26 @@ class SonamuClass {
       `${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.api.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}`);
@@ -330,24 +341,23 @@ class SonamuClass {
 
         // route
         server.route({
-          method: api.options.httpMethod!,
+          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 파싱
@@ -356,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,
           });
@@ -398,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(
@@ -416,26 +427,24 @@ class SonamuClass {
               reply,
               headers: request.headers,
               createSSE,
-              naiteStore: new Map<string, any>(),
+              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) => {
@@ -445,7 +454,7 @@ class SonamuClass {
             } else {
               return reqBody[param.name];
             }
-          })
+          }),
         );
         reply.type(api.options.contentType ?? "application/json");
 
@@ -458,12 +467,13 @@ class SonamuClass {
     };
   }
 
-  startWatcher(): void {
+  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"),
@@ -475,7 +485,7 @@ class SonamuClass {
       const absolutePath = filePath as AbsolutePath;
       assert(
         absolutePath.startsWith(this.apiRootPath),
-        "File path is not within the API root path"
+        "File path is not within the API root path",
       );
 
       if (event !== "change" && event !== "add") {
@@ -484,15 +494,13 @@ class SonamuClass {
 
       try {
         // sonamu.config.ts 변경 시 재시작
-        const isConfigTs =
-          filePath === path.join(this.apiRootPath, "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...`
-            )
+            chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`),
           );
           process.kill(process.pid, "SIGUSR2");
           return;
@@ -517,10 +525,7 @@ class SonamuClass {
     }
   }
 
-  private registerPlugins(
-    server: FastifyInstance,
-    plugins: SonamuServerOptions["plugins"]
-  ) {
+  private async registerPlugins(server: FastifyInstance, plugins: SonamuServerOptions["plugins"]) {
     if (!plugins) {
       return;
     }
@@ -535,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);
@@ -560,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);
@@ -608,15 +613,13 @@ 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: AbsolutePath
-  ): Promise<void> {
+  private async handleFileChange(event: string, filePath: AbsolutePath): Promise<void> {
     // 첫 번째 파일이면 HMR 시작 시간 기록
     if (this.pendingFiles.length === 0) {
       this.hmrStartTime = Date.now();
@@ -624,6 +627,7 @@ class SonamuClass {
     this.pendingFiles.push(filePath);
 
     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(event, filePath);
@@ -642,12 +646,17 @@ class SonamuClass {
 
     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`)}`;
 
     console.log(chalk.black.bgGreen(centerText(msg)));
   }
 
   async destroy(): Promise<void> {
+    const { BaseModel } = await import("../database/base-model");
     await BaseModel.destroy();
     await this.watcher?.close();
     this.storage?.destroy();

package/src/api/validator.ts

@@ -0,0 +1,83 @@
+export const RESERVED_KEYWORDS = new Set([
+  "abstract",
+  "arguments",
+  "async",
+  "await",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "using",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+]);
+
+export class ApiValidationError extends Error {
+  constructor(message: string) {
+    super(`[Sonamu API Validation] ${message}`);
+    this.name = "ApiValidationError";
+  }
+}
+
+export function validateMethodName(methodName: string) {
+  if (RESERVED_KEYWORDS.has(methodName)) {
+    throw new ApiValidationError(
+      `Method name ${methodName} is a reserved keyword. Please choose a different name.`,
+    );
+  }
+}

package/src/bin/build-config.ts

@@ -1,3 +1,8 @@
+/**
+ * 소스 코드가 담길 디렉토리 경로
+ */
+export const SRC_DIR = "src";
+
 /**
  * 빌드 결과물이 담길 디렉토리 경로
  */
@@ -7,7 +12,8 @@ export const BUILD_DIR = "dist";
  * SWC 빌드 명령어
  * .swcrc 설정 사용
  */
-export const SWC_BUILD_COMMAND = `swc src -d ${BUILD_DIR} --strip-leading-paths`;
+export const SWC_BUILD_COMMAND = (configFilePath: string) =>
+  `swc ${SRC_DIR} -d ${BUILD_DIR} --config-file ${configFilePath}  --strip-leading-paths`;
 
 /**
  * TSC 타입 체크 명령어