sonamu 0.5.7 → 0.6.0

package/src/template/index.ts

@@ -0,0 +1,4 @@
+export * from "./template";
+export * from "./helpers";
+export * from "./entity-converter";
+export * from "./zod-converter";

package/src/template/template.ts

@@ -0,0 +1,86 @@
+import { TemplateKey, TemplateOptions } from "../types/types";
+import { EntityNamesRecord } from "../entity/entity-manager";
+import { globAsync } from "../utils/async-utils";
+import { importMembers } from "../utils/esm-utils";
+import path from "path";
+
+export type RenderedTemplate = {
+  target: string;
+  path: string;
+  body: string;
+  importKeys: string[];
+  customHeaders?: string[];
+  preTemplates?: {
+    key: TemplateKey;
+    options: TemplateOptions[TemplateKey];
+  }[];
+};
+
+/**
+ * 템플릿을 나타내는 베이스 클래스입니다.
+ */
+export abstract class Template {
+  private static templates: Map<TemplateKey, Template> = new Map();
+
+  constructor(public key: TemplateKey) {}
+
+  /**
+   * 템플릿 구현체가 있는 디렉토리의 모든 템플릿을 로드합니다.
+   * 템플릿이 필요(Template.find)해지기 전에 최소 한 번 호출해주셔야 합니다.
+   */
+  public static async autoload() {
+    const templateFiles = await globAsync(
+      // Sonamu의 코드베이스는 항상 빌드된 채로 dist 속에 머무르므로,
+      // 현재 파일을 기준으로 마찬가지로 dist 속에 있는 템플릿 구현체 js 파일들을 찾습니다.
+      path.join(import.meta.dirname, "implementations/*.template.js")
+    );
+
+    for (const templateFile of templateFiles) {
+      const templates = await importMembers<any>(templateFile);
+      if (
+        templates.length === 1 &&
+        typeof templates[0].value === "function" &&
+        templates[0].value.prototype instanceof Template
+      ) {
+        // 클래스의 인스턴스를 생성하여 등록
+        const instance = new templates[0].value();
+        this.templates.set(instance.key, instance);
+      } else {
+        throw new Error(
+          `Template ${templateFile} should export only one class that extends Template`
+        );
+      }
+    }
+
+    // console.log(
+    //   chalk.gray(`[Loading] Loaded ${this.templates.size} templates.`)
+    // );
+  }
+
+  /**
+   * 템플릿 **인스턴스**를 key로 찾아옵니다.
+   * 만약 템플릿이 로드(loadAll)되지 않았거나 찾는 템플릿이 없다면 에러를 던집니다.
+   * @param key 
+   * @returns 
+   */
+  public static find(key: TemplateKey): Template {
+    const instance = this.templates.get(key);
+    if (!instance) {
+      throw new Error(`Template ${key} not found. It might be becasuse you tried to find a template before loading all templates. Did you call Template.loadAll()?`);
+    }
+    return instance;
+  }
+
+  public abstract render(
+    options: TemplateOptions[TemplateKey],
+    ...extra: unknown[]
+  ): RenderedTemplate | Promise<RenderedTemplate>;
+
+  public abstract getTargetAndPath(
+    names?: EntityNamesRecord,
+    ...extra: unknown[]
+  ): {
+    target: string;
+    path: string;
+  };
+}

package/src/template/zod-converter.ts

@@ -0,0 +1,219 @@
+import z from "zod";
+import { EntityManager } from "../entity/entity-manager";
+import {
+  EntityProp,
+  isBelongsToOneRelationProp,
+  isBigIntegerProp,
+  isBooleanProp,
+  isDateProp,
+  isDateTimeProp,
+  isDecimalProp,
+  isDoubleProp,
+  isEnumProp,
+  isFloatProp,
+  isIntegerProp,
+  isJsonProp,
+  isOneToOneRelationProp,
+  isRelationProp,
+  isStringProp,
+  isTextProp,
+  isTimeProp,
+  isTimestampProp,
+  isUuidProp,
+  isVirtualProp,
+  RenderingNode,
+} from "../types/types";
+import path from "path";
+import { createImportUrl } from "../utils/esm-utils";
+import { Sonamu } from "../api/sonamu";
+import inflection from "inflection";
+import { getTextTypeLength } from "../api";
+
+/**
+ * Zod 타입 ID로부터 동적으로 Zod 스키마를 로드합니다.
+ * dist 디렉토리에서 ESM으로 import하여 가져옵니다.
+ */
+export async function getZodTypeById(zodTypeId: string): Promise<z.ZodTypeAny> {
+  const modulePath = EntityManager.getModulePath(zodTypeId);
+  const moduleAbsPath = path.join(
+    Sonamu.apiRootPath,
+    "dist",
+    "application",
+    modulePath + ".js"
+  );
+  const importUrl = createImportUrl(moduleAbsPath);
+  const imported = await import(importUrl);
+
+  if (!imported[zodTypeId]) {
+    throw new Error(`존재하지 않는 zodTypeId ${zodTypeId}`);
+  }
+  return imported[zodTypeId].describe(zodTypeId);
+}
+
+/**
+ * Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환합니다.
+ * 재귀적으로 중첩된 타입들을 처리합니다.
+ */
+export function zodTypeToRenderingNode(
+  zodType: z.ZodType<any>,
+  baseKey: string = "root"
+): RenderingNode {
+  const def = {
+    name: baseKey,
+    label: inflection.camelize(baseKey, false),
+    zodType,
+  };
+  if (zodType instanceof z.ZodObject) {
+    const columnKeys = Object.keys(zodType.shape);
+    const children = columnKeys.map((key) => {
+      const innerType = zodType.shape[key];
+      return zodTypeToRenderingNode(innerType, key);
+    });
+    return {
+      ...def,
+      renderType: "object",
+      children,
+    };
+  } else if (zodType instanceof z.ZodArray) {
+    const innerType = (zodType as z.ZodArray<z.ZodType<any>>).def.element;
+    if (innerType instanceof z.ZodString && baseKey.includes("images")) {
+      return {
+        ...def,
+        renderType: "array-images",
+      };
+    }
+    return {
+      ...def,
+      renderType: "array",
+      element: zodTypeToRenderingNode(innerType, baseKey),
+    };
+  } else if (zodType instanceof z.ZodUnion) {
+    const optionNodes = (zodType as z.ZodUnion<z.ZodType[]>).def.options.map(
+      (opt) => zodTypeToRenderingNode(opt, baseKey)
+    );
+    // TODO: ZodUnion이 들어있는 경우 핸들링
+    return optionNodes[0];
+  } else if (zodType instanceof z.ZodOptional) {
+    return {
+      ...zodTypeToRenderingNode(
+        (zodType as z.ZodOptional<z.ZodType>).def.innerType,
+        baseKey
+      ),
+      optional: true,
+    };
+  } else if (zodType instanceof z.ZodNullable) {
+    return {
+      ...zodTypeToRenderingNode(
+        (zodType as z.ZodNullable<z.ZodType>).def.innerType,
+        baseKey
+      ),
+      nullable: true,
+    };
+  } else {
+    return {
+      ...def,
+      renderType: resolveRenderType(baseKey, zodType),
+    };
+  }
+}
+
+/**
+ * Zod 타입과 키 이름으로부터 적절한 RenderType을 결정합니다.
+ */
+function resolveRenderType(
+  key: string,
+  zodType: z.ZodTypeAny
+): RenderingNode["renderType"] {
+  if (zodType instanceof z.ZodDate) {
+    return "datetime";
+  } else if (zodType instanceof z.ZodString) {
+    if (key.includes("img") || key.includes("image")) {
+      return "string-image";
+    } else if (zodType.description === "SQLDateTimeString") {
+      return "string-datetime";
+    } else if (key.endsWith("date")) {
+      return "string-date";
+    } else {
+      return "string-plain";
+    }
+  } else if (zodType instanceof z.ZodNumber) {
+    if (key === "id") {
+      return "number-id";
+    } else if (key.endsWith("_id")) {
+      return "number-fk_id";
+    } else {
+      return "number-plain";
+    }
+  } else if (zodType instanceof z.ZodBoolean) {
+    return "boolean";
+  } else if (zodType instanceof z.ZodEnum) {
+    return "enums";
+  } else if (zodType instanceof z.ZodRecord) {
+    return "record";
+  } else if (zodType instanceof z.ZodAny || zodType instanceof z.ZodUnknown) {
+    return "string-plain";
+  } else if (zodType instanceof z.ZodUnion) {
+    return "string-plain";
+  } else if (zodType instanceof z.ZodLiteral) {
+    return "string-plain";
+  } else {
+    throw new Error(`타입 파싱 불가 ${key} ${zodType.def.type}`);
+  }
+}
+
+/**
+ * EntityProp을 Zod 타입으로 변환합니다.
+ * 각 prop의 타입에 따라 적절한 Zod validator를 생성합니다.
+ */
+export async function propToZodType(prop: EntityProp): Promise<z.ZodTypeAny> {
+  let zodType: z.ZodTypeAny = z.unknown();
+  if (isIntegerProp(prop)) {
+    zodType = z.number().int();
+  } else if (isBigIntegerProp(prop)) {
+    zodType = z.bigint();
+  } else if (isTextProp(prop)) {
+    zodType = z.string().max(getTextTypeLength(prop.textType));
+  } else if (isEnumProp(prop)) {
+    zodType = await getZodTypeById(prop.id);
+  } else if (isStringProp(prop)) {
+    zodType = z.string().max(prop.length);
+  } else if (isFloatProp(prop) || isDoubleProp(prop)) {
+    zodType = z.number();
+  } else if (isDecimalProp(prop)) {
+    zodType = z.string();
+  } else if (isBooleanProp(prop)) {
+    zodType = z.boolean();
+  } else if (isDateProp(prop)) {
+    zodType = z.string().length(10);
+  } else if (isTimeProp(prop)) {
+    zodType = z.string().length(8);
+  } else if (isDateTimeProp(prop)) {
+    zodType = z.date();
+  } else if (isTimestampProp(prop)) {
+    zodType = z.date();
+  } else if (isJsonProp(prop)) {
+    zodType = await getZodTypeById(prop.id);
+  } else if (isUuidProp(prop)) {
+    zodType = z.uuid();
+  } else if (isVirtualProp(prop)) {
+    zodType = await getZodTypeById(prop.id);
+  } else if (isRelationProp(prop)) {
+    if (
+      isBelongsToOneRelationProp(prop) ||
+      (isOneToOneRelationProp(prop) && prop.hasJoinColumn)
+    ) {
+      zodType = z.number().int();
+    }
+  } else {
+    throw new Error(`prop을 zodType으로 변환하는데 실패 ${prop}}`);
+  }
+
+  if ((prop as { unsigned?: boolean }).unsigned) {
+    zodType = (zodType as z.ZodNumber).nonnegative();
+  }
+  if (prop.nullable) {
+    zodType = zodType.nullable();
+  }
+
+  return zodType;
+}

package/src/testing/fixture-manager.ts

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import _ from "lodash";
+import * as _ from "lodash-es";
 import { Sonamu } from "../api";
 import { EntityManager } from "../entity/entity-manager";
 import {
@@ -404,6 +404,9 @@ export class FixtureManagerClass {
       }
     }
 
+    await targetDB.destroy();
+    await sourceDB.destroy();
+
     return _.uniqBy(fixtures, (f) => f.fixtureId);
   }
 
@@ -554,6 +557,8 @@ export class FixtureManagerClass {
       });
     }
 
+    await db.destroy();
+
     return _.uniqBy(records, (r) => `${r.entityId}#${r.data.id}`);
   }
 
@@ -606,6 +611,8 @@ export class FixtureManagerClass {
 
       const q = db.insert(insertData).into(entity.table);
       await q.onDuplicateUpdate.apply(q, Object.keys(insertData));
+      console.log(chalk.green(`Inserted into ${entity.table}: #${fixture.id}`));
+
       return {
         entityId: fixture.entityId,
         id: fixture.id,

package/src/types/types.ts

@@ -1,24 +1,7 @@
 import type { GuardKey } from "./../api/decorators";
-import type { FastifyCorsOptions } from "@fastify/cors";
-import type { FastifyFormbodyOptions } from "@fastify/formbody";
-import type {
-  FastifyInstance,
-  FastifyReply,
-  FastifyRequest,
-  FastifyServerOptions,
-} from "fastify";
-import type { QsPluginOptions } from "fastify-qs";
+import type { FastifyReply, FastifyRequest } from "fastify";
 import { z } from "zod";
 import type { ApiDecoratorOptions, AuthContext, Context } from "../api";
-import type { FastifyMultipartOptions } from "@fastify/multipart";
-import type { Driver } from "../file-storage/driver";
-import type { SsePluginOptions } from "fastify-sse-v2/lib/types";
-import type { FastifyStaticOptions } from "@fastify/static";
-import { SecureSessionPluginOptions } from "@fastify/secure-session";
-import {
-  DeserializeFunction,
-  SerializeFunction,
-} from "@fastify/passport/dist/Authenticator";
 
 /*
   Enums
@@ -256,6 +239,22 @@ export type SMDInput<T extends string> = {
   PropNode
 */
 
+/**
+ * 엔티티의 필드 구조를 트리 형태로 표현하는 중간 노드입니다.
+ *
+ * **목적**: Entity의 subset 필드 표현식(예: "id", "user.name", "tags[]")을
+ * 재귀적인 트리 구조로 파싱하여 Zod 스키마 생성의 중간 단계로 사용합니다.
+ *
+ * **변환 흐름**:
+ * Entity subset → EntityPropNode (트리 구조) → Zod 스키마 → RenderingNode (UI용)
+ *
+ * **nodeType**:
+ * - "plain": 단일 필드 (예: "id", "name")
+ * - "object": 중첩 객체 (예: "user.name" → user 객체)
+ * - "array": 배열 (예: "tags[]" → tags 배열)
+ *
+ * **사용 위치**: entity-converter.ts의 propNodeToZodType()
+ */
 export type EntityPropNode =
   | {
       nodeType: "plain";
@@ -639,6 +638,26 @@ export type ApiParamType =
   | ApiParamType.TupleType;
 
 /* Template */
+/**
+ * UI 컴포넌트 렌더링을 위한 메타데이터 노드입니다.
+ *
+ * **목적**: Zod 스키마로부터 프론트엔드 UI 컴포넌트를 자동 생성하기 위한
+ * 렌더링 정보를 담은 트리 구조입니다. 각 필드가 어떤 UI 컴포넌트로
+ * 표현되어야 하는지(텍스트, 이미지, 날짜, Enum 선택 등)를 명시합니다.
+ *
+ * **변환 흐름**:
+ * Entity subset → EntityPropNode → Zod 스키마 → RenderingNode (UI용) → React 컴포넌트 코드 생성
+ *
+ * **주요 필드**:
+ * - `renderType`: UI 컴포넌트 유형 (string-plain, number-fk_id, enums, array 등)
+ * - `zodType`: 원본 Zod 스키마 (validation 용)
+ * - `children`: 중첩된 객체 필드들 (object일 때)
+ * - `element`: 배열 요소 타입 (array일 때)
+ *
+ * **사용 위치**:
+ * - zod-converter.ts의 zodTypeToRenderingNode()에서 생성
+ * - view_form.template.ts, view_list.template.ts 등에서 React 컴포넌트 코드 생성에 사용
+ */
 // 셀프 참조 타입이므로 Zod 생략하고 직접 정의
 export const RenderingNode = z.any();
 export type RenderingNode = {
@@ -842,7 +861,7 @@ export type SonamuFastifyConfig = {
   contextProvider: (
     defaultContext: Pick<
       Context,
-      "request" | "reply" | "headers" | "createSSE"
+      "request" | "reply" | "headers" | "createSSE" | "naiteStore"
     > &
       AuthContext,
     request: FastifyRequest,
@@ -880,45 +899,3 @@ export type SonamuFastifyConfig = {
         };
   };
 };
-
-export type SonamuServerOptions = {
-  fastify?: FastifyServerOptions;
-
-  listen?: {
-    port: number;
-    host?: string;
-  };
-
-  plugins?: {
-    cors?: boolean | FastifyCorsOptions;
-    formbody?: boolean | FastifyFormbodyOptions;
-    multipart?: boolean | FastifyMultipartOptions;
-    qs?: boolean | QsPluginOptions;
-    sse?: boolean | SsePluginOptions;
-    static?: boolean | FastifyStaticOptions;
-    session?: boolean | SecureSessionPluginOptions;
-
-    custom?: (server: FastifyInstance) => void;
-  };
-
-  auth?:
-    | boolean
-    | {
-        userSerializer: SerializeFunction<unknown, unknown>;
-        userDeserializer: DeserializeFunction<unknown, unknown>;
-      };
-
-  apiConfig: SonamuFastifyConfig;
-
-  storage?: Driver;
-
-  lifecycle?: {
-    onStart?: (server: FastifyInstance) => Promise<void> | void;
-    onShutdown?: (server: FastifyInstance) => Promise<void> | void;
-    onError?: (
-      error: Error,
-      request: FastifyRequest,
-      reply: FastifyReply
-    ) => Promise<void> | void;
-  };
-};

package/src/utils/async-utils.ts

@@ -1,3 +1,6 @@
+import { glob } from "fs/promises";
+import path from "path";
+
 /**
  * 비동기 조건으로 배열을 필터링합니다
  * @example
@@ -62,3 +65,17 @@ export async function reduceAsync<T, U>(
   }
   return accumulator;
 }
+
+/**
+ * 비동기 glob 함수입니다.
+ * AsyncIterableIterator로 날아오는 glob의 반환을 받아 끝까지 돌아서 배열로 반환합니다.
+ * @param pathPattern 
+ * @returns 
+ */
+export async function globAsync(pathPattern: string): Promise<string[]> {
+  const files: string[] = [];
+  for await (const file of glob(path.resolve(pathPattern))) {
+    files.push(file);
+  }
+  return files;
+}

package/src/utils/console-util.ts

@@ -0,0 +1,4 @@
+export function centerText(text: string): string {
+  const margin = (process.stdout.columns - text.length) / 2;
+  return " ".repeat(margin) + text + " ".repeat(margin);
+}

package/src/utils/esm-utils.ts

@@ -0,0 +1,69 @@
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname } from 'path';
+
+/**
+ * import.meta.url로부터 __filename 생성
+ *
+ * @example
+ * const __filename = getFilename(import.meta.url);
+ */
+export function getFilename(metaUrl: string): string {
+  return fileURLToPath(metaUrl);
+}
+
+/**
+ * import.meta.url로부터 __dirname 생성
+ *
+ * @example
+ * const __dirname = getDirname(import.meta.url);
+ */
+export function getDirname(metaUrl: string): string {
+  return dirname(fileURLToPath(metaUrl));
+}
+
+/**
+ * 절대 경로를 file:// URL로 변환 (동적 임포트용)
+ *
+ * @param absolutePath - 절대 파일 경로
+ * @returns file:// URL 문자열
+ *
+ * @example
+ * const url = createImportUrl('/path/to/file.js');
+ * await import(url);
+ */
+export function createImportUrl(
+  absolutePath: string
+): string {
+  const fileUrl = pathToFileURL(absolutePath).href;
+  return fileUrl;
+}
+
+/**
+ * HMR 환경 감지
+ *
+ * @returns hot reload 환경인지 여부
+ */
+export function isHotReloadServer(): boolean {
+  return process.env.HOT === 'yes';
+}
+
+/**
+ * 캐시를 무시하고 새로 임포트(cache busting)하는데, 이때 가져온 모듈의 exported members들을 배열로 가져옵니다.
+ *
+ * 가령 모듈에서 `export const user = { id: number; name: string; }` 이렇게 정의했다면,
+ * 이 함수는 `[{ name: "user", value: { id: number; name: string; } }]` 이렇게 반환합니다.
+ *
+ * @param filePath
+ * @returns { name: string; value: ExportedMemberT }[]
+ */
+export async function importMembers<ExportedMemberT>(
+  filePath: string
+): Promise<{ name: string; value: ExportedMemberT }[]> {
+  const imported = await import(createImportUrl(filePath));
+
+  const allExportedMembers = Object.entries<ExportedMemberT>(imported).map(
+    ([name, value]) => ({ name, value })
+  );
+
+  return allExportedMembers;
+}

package/src/utils/path-utils.ts

@@ -0,0 +1,102 @@
+import { isHotReloadServer } from "./esm-utils.js";
+
+/**
+ * API 패키지 내부 상대 경로 (src/ 또는 dist/로 시작)
+ *
+ * **사용 위치**: API 패키지 내부 파일 참조
+ * **예시**:
+ * - `"src/application/user/user.model.ts"`
+ * - `"dist/application/user/user.model.js"`
+ *
+ * **기준점**: `Sonamu.apiRootPath` (일반적으로 프로젝트의 `/api` 디렉토리)
+ */
+export type ApiRelativePath = `${"src" | "dist"}/${string}` | 'sonamu.config.ts';
+
+/**
+ * 앱 루트 기준 상대 경로 (api/, web/ 등 타겟 디렉토리로 시작)
+ *
+ * **사용 위치**: 다른 타겟(api, web 등)의 파일 참조
+ * **예시**:
+ * - `"api/src/application/user/user.model.ts"`
+ * - `"web/src/pages/admin/users/index.tsx"`
+ * - `"app/dist/index.js"`
+ *
+ * **기준점**: `Sonamu.appRootPath` (일반적으로 모노레포 루트)
+ */
+export type AppRelativePath = `${string}/${"src" | "dist"}/${string}`;
+
+/**
+ * 시스템 절대 경로 (루트 / 부터 시작)
+ *
+ * **사용 위치**: 파일시스템 직접 접근, glob 패턴
+ * **예시**: `"/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"`
+ *
+ * **중요**:
+ * - import 시에는 로더가 알아서 src/dist 변환해주므로 어느 경로든 가능
+ * - fs 직접 접근 시에는 실제 존재하는 경로를 사용해야 함
+ *   - Dev: src/*.ts 경로 사용
+ *   - Prod: dist/*.js 경로 사용
+ */
+export type AbsolutePath = `/${string}`;
+
+/**
+ * 어떤 경로가 들어오든, 현재 실행 환경에 맞는 경로로 바꿔줍니다.
+ *
+ * "src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts"
+ * "src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js"
+ * "dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts"
+ * "dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js"
+ *
+ * "/src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "/src/application/user/user.model.ts"
+ * "/src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ * "/dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ * "/dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ *
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"
+ *
+ * "src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts?hot=1234567890"
+ * "src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js?hot=1234567890"
+ * "dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts?hot=1234567890"
+ * "dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js?hot=1234567890"
+ *
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"
+ *
+ * @param anyPath
+ * @returns
+ */
+export function runtimePath(
+  anyPath: string,
+  isDev: boolean = isHotReloadServer()
+): string {
+  if (isDev) {
+    return anyPath.replace(/dist\//, "src/").replace(/\.js/, ".ts");
+  } else {
+    return anyPath.replace(/src\//, "dist/").replace(/\.ts/, ".js");
+  }
+}