sonamu 0.4.14 → 0.5.1

package/src/api/sonamu.ts

@@ -1,23 +1,36 @@
+import { AsyncLocalStorage } from "async_hooks";
 import chalk from "chalk";
-import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
-import { IncomingMessage, Server, ServerResponse } from "http";
-import { ZodError } from "zod";
+import fastify from "fastify";
+import { readFile } from "fs/promises";
 import path from "path";
-import fs from "fs-extra";
-import { getZodObjectFromApi } from "./code-converters";
-import { Context } from "./context";
-import { BadRequestException } from "../exceptions/so-exceptions";
-import { EntityManager } from "../entity/entity-manager";
-import { fastifyCaster } from "./caster";
-import { ApiParam, ApiParamType } from "../types/types";
-import { Syncer } from "../syncer/syncer";
+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 type { Driver } from "../file-storage/driver";
+import { createSSEFactory } from "../stream/sse";
+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 { ApiDecoratorOptions } from "./decorators";
 import { humanizeZodError } from "../utils/zod-error";
-import { DatabaseDriver, SonamuDBConfig } from "../database/types";
-import { DB } from "../database/db";
-import { AsyncLocalStorage } from "async_hooks";
+import { fastifyCaster } from "./caster";
+import { getZodObjectFromApi } from "./code-converters";
+import type { Context, UploadContext } from "./context";
+import type { ExtendedApi } from "./decorators";
 
 export type SonamuConfig = {
   projectName?: string;
@@ -30,54 +43,24 @@ export type SonamuConfig = {
   route: {
     prefix: string;
   };
+  timezone?: string;
+  ui?: {
+    port: number;
+  };
 };
 export type SonamuSecrets = {
   [key: string]: string;
 };
-type SonamuFastifyConfig = {
-  contextProvider: (
-    defaultContext: Pick<Context, "headers" | "reply">,
-    request: FastifyRequest,
-    reply: FastifyReply
-  ) => Context;
-  guardHandler: (
-    guard: string,
-    request: FastifyRequest,
-    api: {
-      typeParameters: ApiParamType.TypeParam[];
-      parameters: ApiParam[];
-      returnType: ApiParamType;
-      modelName: string;
-      methodName: string;
-      path: string;
-      options: ApiDecoratorOptions;
-    }
-  ) => void;
-  cache?: {
-    get: (key: string) => Promise<unknown | null>;
-    put: (key: string, value: unknown, ttl?: number) => Promise<void>;
-    resolveKey: (
-      path: string,
-      reqBody: {
-        [key: string]: unknown;
-      }
-    ) =>
-      | {
-          cache: false;
-        }
-      | {
-          cache: true;
-          key: string;
-          ttl?: number;
-        };
-  };
-};
 class SonamuClass {
   public isInitialized: boolean = false;
   public asyncLocalStorage: AsyncLocalStorage<{
     context: Context;
   }> = new AsyncLocalStorage();
 
+  public uploadStorage: AsyncLocalStorage<{
+    uploadContext: UploadContext;
+  }> = new AsyncLocalStorage();
+
   public getContext(): Context {
     const store = this.asyncLocalStorage.getStore();
     if (store?.context) {
@@ -86,6 +69,16 @@ class SonamuClass {
     throw new Error("Sonamu cannot find context");
   }
 
+  public getUploadContext(): UploadContext {
+    const store = this.uploadStorage.getStore();
+    if (store?.uploadContext) {
+      return store.uploadContext;
+    }
+    throw new Error(
+      "Sonamu cannot find upload context. Did you use @upload decorator?"
+    );
+  }
+
   private _apiRootPath: string | null = null;
   set apiRootPath(apiRootPath: string) {
     this._apiRootPath = apiRootPath;
@@ -104,24 +97,13 @@ class SonamuClass {
   set dbConfig(dbConfig: SonamuDBConfig) {
     this._dbConfig = dbConfig;
   }
-  get dbConfig() {
+  get dbConfig(): SonamuDBConfig {
     if (this._dbConfig === null) {
       throw new Error("Sonamu has not been initialized");
     }
     return this._dbConfig!;
   }
 
-  private _dbClient: DatabaseDriver | null = null;
-  set dbClient(_dbClient: DatabaseDriver) {
-    this._dbClient = _dbClient;
-  }
-  get dbClient() {
-    if (this._dbClient === null) {
-      throw new Error("Sonamu has not been initialized");
-    }
-    return this._dbClient!;
-  }
-
   private _syncer: Syncer | null = null;
   set syncer(syncer: Syncer) {
     this._syncer = syncer;
@@ -152,6 +134,21 @@ class SonamuClass {
     return this._secrets;
   }
 
+  private _storage: Driver | null = null;
+  set storage(storage: Driver) {
+    this._storage = storage;
+  }
+  get storage(): Driver | null {
+    return this._storage;
+  }
+
+  // HMR 처리
+  public watcher: FSWatcher | null = null;
+  private pendingFiles: string[] = [];
+  private hmrStartTime: number = 0;
+
+  public server: FastifyInstance | null = null;
+
   async initForTesting() {
     await this.init(true, false, undefined, true);
   }
@@ -171,26 +168,25 @@ class SonamuClass {
       );
 
     // API 루트 패스
-    this.apiRootPath = apiRootPath ?? (await findApiRootPath());
+    this.apiRootPath = apiRootPath ?? findApiRootPath();
     const configPath = path.join(this.apiRootPath, "sonamu.config.json");
     const secretsPath = path.join(this.apiRootPath, "sonamu.secrets.json");
-    if (fs.existsSync(configPath) === false) {
+    if (!(await exists(configPath))) {
       throw new Error(`Cannot find sonamu.config.json in ${configPath}`);
     }
     this.config = JSON.parse(
-      fs.readFileSync(configPath).toString()
+      (await readFile(configPath)).toString()
     ) as SonamuConfig;
-    if (fs.existsSync(secretsPath)) {
+    if (await exists(secretsPath)) {
       this.secrets = JSON.parse(
-        fs.readFileSync(secretsPath).toString()
+        (await readFile(secretsPath)).toString()
       ) as SonamuSecrets;
     }
 
     // DB 로드
-    const baseConfig = await DB.getBaseConfig(this.apiRootPath);
-    this.dbClient = baseConfig.client;
-    DB.init(baseConfig as any);
-    this.dbConfig = DB.fullConfig;
+    this.dbConfig = await DB.readKnexfile();
+    !doSilent && console.log(chalk.green("DB Config Loaded!"));
+    attachOnDuplicateUpdate();
 
     // 테스팅인 경우 엔티티 로드 & 싱크 없이 중단
     if (forTesting) {
@@ -199,9 +195,11 @@ class SonamuClass {
     }
 
     // Entity 로드
+    const { EntityManager } = await import("../entity/entity-manager");
     await EntityManager.autoload(doSilent);
 
     // Syncer
+    const { Syncer } = await import("../syncer/syncer");
     this.syncer = new Syncer();
 
     // Autoload: Models / Types / APIs
@@ -212,17 +210,48 @@ class SonamuClass {
     if (isLocal() && !isTest() && enableSync) {
       await this.syncer.sync();
 
-      fetch("http://127.0.0.1:57001/api/reload", {
-        method: "GET",
-      }).catch((e) =>
-        console.log(chalk.dim(`Failed to reload Sonamu UI: ${e.message}`))
-      );
+      // FIXME: hmr 설정된 경우만 워처 시작
+      this.startWatcher();
+
+      this.syncer.syncUI();
     }
 
     this.isInitialized = true;
     !doSilent && console.timeEnd(chalk.cyan("Sonamu.init"));
   }
 
+  async createServer(
+    options: SonamuServerOptions,
+    initOptions?: {
+      enableSync?: boolean;
+      doSilent?: boolean;
+    }
+  ) {
+    const server = fastify(options.fastify);
+    this.server = server;
+
+    // Storage 설정 저장
+    if (options.storage) {
+      this.storage = options.storage;
+    }
+
+    // 플러그인 등록
+    if (options.plugins) {
+      this.registerPlugins(server, options.plugins);
+    }
+
+    // API 라우팅 설정
+    await this.withFastify(server, options.apiConfig, {
+      enableSync: initOptions?.enableSync,
+      doSilent: initOptions?.doSilent,
+    });
+
+    // 서버 시작
+    await this.boot(server, options);
+
+    return server;
+  }
+
   async withFastify(
     server: FastifyInstance<Server, IncomingMessage, ServerResponse>,
     config: SonamuFastifyConfig,
@@ -235,6 +264,27 @@ class SonamuClass {
       await this.init(options?.doSilent, options?.enableSync);
     }
 
+    this.server = server;
+
+    // timezone 설정
+    const timezone = this.config.timezone;
+    if (timezone) {
+      const DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ssXXX";
+      // 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$/;
+
+      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 value;
+        });
+      });
+      !options?.doSilent &&
+        console.log(chalk.green(`Timezone set to ${timezone}`));
+    }
+
     // 전체 라우팅 리스트
     server.get(
       `${this.config.route.prefix}/routes`,
@@ -251,107 +301,300 @@ class SonamuClass {
       }
     );
 
-    // API 라우팅 등록
-    this.syncer.apis.map((api) => {
-      // model
-      if (this.syncer.models[api.modelName] === undefined) {
-        throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);
-      }
-      const model = this.syncer.models[api.modelName];
+    // API 라우팅 (로컬HMR 상태와 구분)
+    if (isLocal()) {
+      server.all("*", (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()
+        );
+        if (found) {
+          return this.getApiHandler(found, config)(request, reply);
+        }
+        throw new NotFoundException("존재하지 않는 API 접근입니다.");
+      });
+    } else {
+      this.syncer.apis.map((api) => {
+        // model
+        if (this.syncer.models[api.modelName] === undefined) {
+          throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);
+        }
+
+        // route
+        server.route({
+          method: api.options.httpMethod!,
+          url: this.config.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)
+      );
 
       // 파라미터 정보로 zod 스키마 빌드
       const ReqType = getZodObjectFromApi(api, this.syncer.types);
 
-      // route
-      server.route({
-        method: api.options.httpMethod!,
-        url: this.config.route.prefix + api.path,
-        handler: async (request, reply): Promise<unknown> => {
-          (api.options.guards ?? []).every((guard) =>
-            config.guardHandler(guard, request, api)
-          );
-
-          // request 파싱
-          const which = api.options.httpMethod === "GET" ? "query" : "body";
-          let reqBody: {
-            [key: string]: unknown;
-          };
-          try {
-            reqBody = fastifyCaster(ReqType).parse(request[which] ?? {});
-          } catch (e) {
-            if (e instanceof ZodError) {
-              const messages = humanizeZodError(e)
-                .map((issue) => issue.message)
-                .join(" ");
-              throw new BadRequestException(messages);
-            } else {
-              throw e;
-            }
-          }
+      // request 파싱
+      const which = api.options.httpMethod === "GET" ? "query" : "body";
+      let reqBody: {
+        [key: string]: unknown;
+      };
+      try {
+        reqBody = fastifyCaster(ReqType).parse(request[which] ?? {});
+      } catch (e) {
+        if (e instanceof ZodError) {
+          const messages = humanizeZodError(e)
+            .map((issue) => issue.message)
+            .join(" ");
+          throw new BadRequestException(messages, {
+            zodError: e,
+          });
+        } else {
+          throw e;
+        }
+      }
+
+      // Content-Type
+      reply.type(api.options.contentType ?? "application/json");
 
-          // Content-Type
-          reply.type(api.options.contentType ?? "application/json");
-
-          // 캐시
-          const { cacheKey, cacheTtl, cachedData } = await (async () => {
-            if (config.cache) {
-              try {
-                const cacheKeyRes = config.cache.resolveKey(api.path, reqBody);
-                if (cacheKeyRes.cache === false) {
-                  return { cacheKey: null, cachedData: null };
-                }
-
-                const cacheKey = cacheKeyRes.key;
-                const cacheTtl = cacheKeyRes.ttl;
-                const cachedData = await config.cache.get(cacheKey);
-                return { cacheKey, cacheTtl, cachedData };
-              } catch (e) {
-                console.error(e);
-              }
+      // 캐시
+      const { cacheKey, cacheTtl, cachedData } = await (async () => {
+        if (config.cache) {
+          try {
+            const cacheKeyRes = config.cache.resolveKey(api.path, reqBody);
+            if (cacheKeyRes.cache === false) {
               return { cacheKey: null, cachedData: null };
             }
-            return { cacheKey: null, cachedData: null };
-          })();
-          if (cachedData !== null) {
-            return cachedData;
+
+            const cacheKey = cacheKeyRes.key;
+            const cacheTtl = cacheKeyRes.ttl;
+            const cachedData = await config.cache.get(cacheKey);
+            return { cacheKey, cacheTtl, cachedData };
+          } catch (e) {
+            console.error(e);
           }
+          return { cacheKey: null, cachedData: null };
+        }
+        return { cacheKey: null, cachedData: null };
+      })();
+      if (cachedData !== null) {
+        return cachedData;
+      }
+
+      // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.
+      const createSSE = (<T extends ZodObject>(
+        _request: FastifyRequest,
+        _reply: FastifyReply,
+        _events: T
+      ) => createSSEFactory(_request.socket, _reply, _events)).bind(
+        null,
+        request,
+        reply
+      );
 
-          // 결과 (AsyncLocalStorage 적용)
-          const context = config.contextProvider(
-            {
-              headers: request.headers,
-              reply,
-            },
+      // 결과 (AsyncLocalStorage 적용)
+      const context: Context = {
+        ...config.contextProvider(
+          {
             request,
-            reply
-          );
-          return this.asyncLocalStorage.run({ context }, async () => {
-            const result = await (model as any)[api.methodName].apply(
-              model,
-              api.parameters.map((param) => {
-                // Context 인젝션
-                if (ApiParamType.isContext(param.type)) {
-                  return context;
-                } else {
-                  return reqBody[param.name];
-                }
-              })
-            );
-            reply.type(api.options.contentType ?? "application/json");
-
-            // 캐시 키 있는 경우 갱신 후 저장
-            if (config.cache && cacheKey) {
-              await config.cache.put(cacheKey, result, cacheTtl);
+            reply,
+            headers: request.headers,
+            createSSE,
+          },
+          request,
+          reply
+        ),
+      };
+
+      const model = this.syncer.models[api.modelName];
+      return this.asyncLocalStorage.run({ context }, async () => {
+        const result = await (model as any)[api.methodName].apply(
+          model,
+          api.parameters.map((param) => {
+            // Context 인젝션
+            if (ApiParamType.isContext(param.type)) {
+              return context;
+            } else {
+              return reqBody[param.name];
             }
-            return result;
-          });
-        },
-      }); // END server.route
+          })
+        );
+        reply.type(api.options.contentType ?? "application/json");
+
+        // 캐시 키 있는 경우 갱신 후 저장
+        if (config.cache && cacheKey) {
+          await config.cache.put(cacheKey, result, cacheTtl);
+        }
+        return result;
+      });
+    };
+  }
+
+  startWatcher(): void {
+    const watchPath = path.join(this.apiRootPath, "src");
+    const chokidar = require("chokidar") as typeof import("chokidar");
+    this.watcher = chokidar.watch(watchPath, {
+      ignored: (path, stats) =>
+        (!!stats?.isFile() &&
+          !path.endsWith(".ts") &&
+          !path.endsWith(".json")) ||
+        path.endsWith("src/index.ts"),
+      persistent: true,
+      ignoreInitial: true,
+    });
+    this.watcher.on("all", async (event: string, filePath: string) => {
+      if (event !== "change" && event !== "add") {
+        return;
+      }
+
+      try {
+        await this.handleFileChange(event, filePath);
+      } catch (e) {
+        console.error(e);
+      }
     });
   }
 
+  /*
+     A function that automatically handles init and destroy when using Sonamu via scripts.    
+  */
+  async runScript(fn: () => Promise<void>) {
+    await this.init(true, false, undefined, false);
+    try {
+      await fn();
+    } finally {
+      await this.destroy();
+    }
+  }
+
+  private registerPlugins(
+    server: FastifyInstance,
+    plugins: SonamuServerOptions["plugins"]
+  ) {
+    if (!plugins) {
+      return;
+    }
+
+    const pluginsModules = {
+      cors: "@fastify/cors",
+      formbody: "@fastify/formbody",
+      multipart: "@fastify/multipart",
+      qs: "fastify-qs",
+      sse: "fastify-sse-v2",
+    } as const;
+
+    const registerPlugin = <K extends keyof NonNullable<typeof plugins>>(
+      key: K,
+      pluginName: string
+    ) => {
+      const option = plugins[key];
+      if (!option) return;
+
+      if (option === true) {
+        server.register(import(pluginName));
+      } else {
+        server.register(import(pluginName), option);
+      }
+    };
+
+    Object.entries(pluginsModules).forEach(([key, pluginName]) => {
+      registerPlugin(key as keyof typeof plugins, pluginName);
+    });
+
+    if (plugins.custom) {
+      plugins.custom(server);
+    }
+  }
+
+  private async boot(server: FastifyInstance, options: SonamuServerOptions) {
+    const port = options.listen?.port ?? 3000;
+    const host = options.listen?.host ?? "localhost";
+
+    server.addHook("onClose", async () => {
+      await options.lifecycle?.onShutdown?.(server);
+      await this.destroy();
+    });
+
+    const shutdown = async () => {
+      try {
+        await server.close();
+        process.exit(0);
+      } catch (err) {
+        console.error("Error during shutdown:", err);
+        process.exit(1);
+      }
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+
+    if (options.lifecycle?.onError) {
+      server.setErrorHandler(options.lifecycle?.onError);
+    }
+
+    server
+      .listen({ port, host })
+      .then(async () => {
+        await options.lifecycle?.onStart?.(server);
+      })
+      .catch(async (err) => {
+        console.error(chalk.red("Failed to start server:", err));
+        await shutdown();
+      });
+  }
+
+  private async handleFileChange(
+    event: string,
+    filePath: string
+  ): Promise<void> {
+    // 첫 번째 파일이면 HMR 시작 시간 기록
+    if (this.pendingFiles.length === 0) {
+      this.hmrStartTime = Date.now();
+    }
+
+    this.pendingFiles.push(filePath);
+
+    const relativePath = filePath.replace(this.apiRootPath, "api");
+    console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));
+
+    await this.syncer.syncFromWatcher([filePath]);
+
+    // 처리 완료된 파일을 대기 목록에서 제거
+    this.pendingFiles = this.pendingFiles.slice(1);
+
+    // 모든 파일 처리가 완료되면 최종 메시지 출력
+    if (this.pendingFiles.length === 0) {
+      await this.finishHMR();
+    }
+  }
+
+  private async finishHMR(): Promise<void> {
+    await this.syncer.saveChecksums(await this.syncer.getCurrentChecksums());
+
+    const endTime = Date.now();
+    const totalTime = endTime - this.hmrStartTime;
+    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))
+    );
+  }
+
   async destroy(): Promise<void> {
-    await DB.destroy();
+    const { BaseModel } = require("../database/base-model");
+    await BaseModel.destroy();
+    await this.watcher?.close();
+    this.storage?.destroy();
   }
 }
 export const Sonamu = new SonamuClass();