sonamu 0.6.0 → 0.7.1

package/src/typings/knex.d.ts

@@ -1,19 +1,17 @@
-import { Knex } from "knex";
+/** biome-ignore-all lint/correctness/noUnusedImports: d.ts */
+/** biome-ignore-all lint/suspicious/noExplicitAny: d.ts */
+/** biome-ignore-all lint/correctness/noUnusedVariables: d.ts */
+
+import type { Knex } from "knex";
 
 declare module "knex" {
   namespace Knex {
     interface QueryBuilder {
-      onDuplicateUpdate<TRecord extends {}, TResult>(
-        ...columns: string[]
-      ): Knex.QueryBuilder<TRecord, TResult>;
-
-      columnInfo<TRecord>(
-        column?: keyof TRecord
-      ): Promise<Knex.ColumnInfo | ColumnInfosObj>;
+      columnInfo<TRecord>(column?: keyof TRecord): Promise<Knex.ColumnInfo | ColumnInfosObj>;
 
       whereBetween<TRecord, TResult>(
         columnName: string,
-        range: readonly [any, any]
+        range: readonly [any, any],
       ): Knex.QueryBuilder;
     }
 

package/src/utils/async-utils.ts

@@ -8,12 +8,10 @@ import path from "path";
  */
 export async function filterAsync<T>(
   arr: T[],
-  predicate: (item: T, index: number, array: T[]) => Promise<boolean>
+  predicate: (item: T, index: number, array: T[]) => Promise<boolean>,
 ): Promise<T[]> {
   const results = await Promise.all(
-    arr.map((item, index) =>
-      predicate(item, index, arr).then((keep) => ({ item, keep }))
-    )
+    arr.map((item, index) => predicate(item, index, arr).then((keep) => ({ item, keep }))),
   );
   return results.filter((r) => r.keep).map((r) => r.item);
 }
@@ -25,7 +23,7 @@ export async function filterAsync<T>(
  */
 export async function everyAsync<T>(
   arr: T[],
-  predicate: (item: T, index: number, array: T[]) => Promise<boolean>
+  predicate: (item: T, index: number, array: T[]) => Promise<boolean>,
 ): Promise<boolean> {
   for (let i = 0; i < arr.length; i++) {
     if (!(await predicate(arr[i], i, arr))) {
@@ -42,11 +40,9 @@ export async function everyAsync<T>(
  */
 export async function mapAsync<T, U>(
   arr: T[],
-  mapper: (item: T, index: number, array: T[]) => Promise<U>
+  mapper: (item: T, index: number, array: T[]) => Promise<U>,
 ): Promise<U[]> {
-  return Promise.all(
-    arr.map((item, index) => mapper(item, index, arr))
-  );
+  return Promise.all(arr.map((item, index) => mapper(item, index, arr)));
 }
 
 /**
@@ -57,7 +53,7 @@ export async function mapAsync<T, U>(
 export async function reduceAsync<T, U>(
   arr: T[],
   reducer: (accumulator: U, currentValue: T, index: number, array: T[]) => Promise<U>,
-  initialValue: U
+  initialValue: U,
 ): Promise<U> {
   let accumulator = initialValue;
   for (let i = 0; i < arr.length; i++) {
@@ -69,8 +65,8 @@ export async function reduceAsync<T, U>(
 /**
  * 비동기 glob 함수입니다.
  * AsyncIterableIterator로 날아오는 glob의 반환을 받아 끝까지 돌아서 배열로 반환합니다.
- * @param pathPattern 
- * @returns 
+ * @param pathPattern
+ * @returns
  */
 export async function globAsync(pathPattern: string): Promise<string[]> {
   const files: string[] = [];

package/src/utils/console-util.ts

@@ -1,4 +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/controller.ts

@@ -22,3 +22,6 @@ export function isProduction(): boolean {
 export function isTest(): boolean {
   return isLocal() && process.env.NODE_ENV === "test";
 }
+export function isHotReloadServer(): boolean {
+  return process.env.HOT === "yes";
+}

package/src/utils/esm-utils.ts

@@ -1,5 +1,5 @@
-import { fileURLToPath, pathToFileURL } from 'url';
-import { dirname } from 'path';
+import { dirname } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 
 /**
  * import.meta.url로부터 __filename 생성
@@ -31,22 +31,11 @@ export function getDirname(metaUrl: string): string {
  * const url = createImportUrl('/path/to/file.js');
  * await import(url);
  */
-export function createImportUrl(
-  absolutePath: string
-): string {
+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들을 배열로 가져옵니다.
  *
@@ -57,13 +46,14 @@ export function isHotReloadServer(): boolean {
  * @returns { name: string; value: ExportedMemberT }[]
  */
 export async function importMembers<ExportedMemberT>(
-  filePath: string
+  filePath: string,
 ): Promise<{ name: string; value: ExportedMemberT }[]> {
   const imported = await import(createImportUrl(filePath));
 
-  const allExportedMembers = Object.entries<ExportedMemberT>(imported).map(
-    ([name, value]) => ({ name, value })
-  );
+  const allExportedMembers = Object.entries<ExportedMemberT>(imported).map(([name, value]) => ({
+    name,
+    value,
+  }));
 
   return allExportedMembers;
 }

package/src/utils/formatter.ts

@@ -0,0 +1,109 @@
+import { Biome } from "@biomejs/js-api/nodejs";
+import { Naite } from "../naite/naite";
+import { isTest } from "./controller";
+
+const biome = new Biome();
+let projectKey: number = -1;
+
+export function setupBiome(path: string) {
+  if (projectKey !== -1) {
+    return;
+  }
+
+  projectKey = biome.openProject(path).projectKey;
+  biome.applyConfiguration(projectKey, {
+    formatter: {
+      enabled: true,
+      formatWithErrors: false,
+      indentStyle: "space",
+      indentWidth: 2,
+      lineEnding: "lf",
+      lineWidth: 100,
+      attributePosition: "auto",
+    },
+    linter: {
+      enabled: true,
+      rules: {
+        recommended: true,
+        style: {
+          useNodejsImportProtocol: "off",
+        },
+        correctness: {
+          useParseIntRadix: "off",
+          noEmptyPattern: "off",
+          noUnusedImports: {
+            level: "warn",
+            fix: "safe",
+          },
+        },
+        a11y: {
+          noLabelWithoutControl: "off",
+        },
+        complexity: {
+          noBannedTypes: "off",
+        },
+        suspicious: {
+          noArrayIndexKey: "off",
+        },
+      },
+    },
+    javascript: {
+      formatter: {
+        jsxQuoteStyle: "double",
+        quoteProperties: "asNeeded",
+        trailingCommas: "all",
+        semicolons: "always",
+        arrowParentheses: "always",
+        bracketSpacing: true,
+        bracketSameLine: false,
+        quoteStyle: "double",
+        attributePosition: "auto",
+      },
+    },
+    json: {
+      formatter: {
+        indentWidth: 2,
+      },
+    },
+    assist: {
+      enabled: true,
+      actions: {
+        source: {
+          organizeImports: "on",
+        },
+      },
+    },
+  });
+}
+
+export function formatCode(code: string, parser: "typescript" | "json", filePath: string) {
+  Naite.t("formatCode", { code, parser });
+
+  if (projectKey === -1) {
+    console.warn("Biome is not setup. Please call setupBiome first.");
+    return code;
+  }
+
+  // 포맷팅을 먼저 해야함
+  const formatted = biome.formatContent(projectKey, code, { filePath });
+  Naite.t("formatCode:formatted", formatted);
+  if (formatted.diagnostics.filter((d) => d.severity === "error").length > 0) {
+    console.error(formatted.diagnostics);
+    throw new Error("Biome format error");
+  }
+
+  // 린팅을 그 다음에
+  const linted = biome.lintContent(projectKey, formatted.content, {
+    filePath,
+    fixFileMode: "safeAndUnsafeFixes",
+  });
+  if (linted.diagnostics.filter((d) => d.severity === "error").length > 0) {
+    Naite.t("formatCode:linted:content", linted.content);
+    Naite.t("formatCode:linted:diagnostics", linted.diagnostics);
+    !isTest() && console.dir(linted.diagnostics, { depth: null });
+    throw new Error("Biome lint error");
+  }
+  Naite.t("formatCode:linted", linted);
+
+  return linted.content;
+}

package/src/utils/fs-utils.ts

@@ -1,4 +1,4 @@
-import { PathLike, constants } from "fs";
+import { constants, type PathLike } from "fs";
 import { access } from "fs/promises";
 
 /**

package/src/utils/lodash-able.ts

@@ -1,7 +1,4 @@
-export function wrapIf(
-  source: string,
-  predicate: (str: string) => [boolean, string]
-): string {
+export function wrapIf(source: string, predicate: (str: string) => [boolean, string]): string {
   const [ok, wrapped] = predicate(source);
   return ok ? wrapped : source;
 }

package/src/utils/object-utils.ts

@@ -0,0 +1,217 @@
+type Primitive = string | number | boolean | null | undefined;
+
+type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | BigInt64Array
+  | BigUint64Array;
+
+type StructuredCloneable = Date | ArrayBuffer | TypedArray;
+
+/** 직렬화 불가 타입 (명시적 제외용) */
+type NonSerializable =
+  | Function
+  | Promise<unknown>
+  | RegExp
+  | symbol
+  // biome-ignore lint/suspicious/noExplicitAny: WeakMap의 제네릭 파라미터
+  | WeakMap<any, any>
+  // biome-ignore lint/suspicious/noExplicitAny: WeakSet의 제네릭 파라미터
+  | WeakSet<any>
+  // biome-ignore lint/suspicious/noExplicitAny: WeakRef의 제네릭 파라미터
+  | WeakRef<any>;
+
+/** 재귀적 직렬화 가능 타입 */
+export type Serializable =
+  | Primitive
+  | StructuredCloneable
+  | SerializableArray
+  | SerializableMap
+  | SerializableSet
+  | SerializableObject;
+
+interface SerializableArray extends Array<Serializable> {}
+
+interface SerializableMap extends Map<Serializable, Serializable> {}
+
+interface SerializableSet extends Set<Serializable> {}
+
+interface SerializableObject {
+  [key: string]: Serializable;
+}
+
+/**
+ * 주어진 타입 T가 직렬화 가능한지 검증하는 조건부 타입
+ * 직렬화 불가한 값이 포함되어 있으면 never를 반환하여 타입 에러가 발생합니다
+ */
+export type AssertSerializable<T> = T extends NonSerializable
+  ? never
+  : T extends Primitive | StructuredCloneable
+    ? T
+    : T extends Map<infer K, infer V>
+      ? Map<AssertSerializable<K>, AssertSerializable<V>>
+      : T extends Set<infer U>
+        ? Set<AssertSerializable<U>>
+        : T extends Array<infer U>
+          ? AssertSerializable<U>[]
+          : T extends object
+            ? { [K in keyof T]: AssertSerializable<T[K]> }
+            : T;
+
+export interface SerializableCheckResult {
+  valid: boolean;
+  reason?: string;
+}
+
+/**
+ * 값이 Vitest worker/process 간 전달 가능한지 검증합니다.
+ * Serializable하다는 것은 결국 message port와 process.send를 통해 전달 가능한 것을 의미합니다.
+ *
+ * @param value - 검증할 값
+ * @param path - 현재 경로 (에러 메시지용, 내부 재귀에서 사용)
+ * @param seen - 순환 참조 감지용 WeakSet (내부 재귀에서 사용)
+ * @returns 검증 결과 { valid: boolean, reason?: string }
+ *
+ * @example
+ * isSerializable({ a: 1, b: "hello" }) // { valid: true }
+ * isSerializable({ fn: () => {} }) // { valid: false, reason: "Function at fn" }
+ * isSerializable({ deep: { nested: Promise.resolve() } }) // { valid: false, reason: "Promise at deep.nested" }
+ */
+export function isSerializable(
+  value: unknown,
+  path: string[] = [],
+  seen: WeakSet<object> = new WeakSet(),
+): SerializableCheckResult {
+  // typeof null === 'object'이므로 먼저 처리
+  if (value === null) {
+    return { valid: true };
+  }
+
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean" || type === "undefined") {
+    return { valid: true };
+  }
+  if (type === "bigint") {
+    return { valid: true };
+  }
+
+  if (type === "function") {
+    return { valid: false, reason: `Function at ${formatPath(path)}` };
+  }
+  if (type === "symbol") {
+    return { valid: false, reason: `Symbol at ${formatPath(path)}` };
+  }
+
+  if (type === "object") {
+    const obj = value as object;
+
+    if (obj instanceof Promise) {
+      return { valid: false, reason: `Promise at ${formatPath(path)}` };
+    }
+
+    if (obj instanceof RegExp) {
+      return { valid: false, reason: `RegExp at ${formatPath(path)}` };
+    }
+
+    if (obj instanceof WeakMap) {
+      return { valid: false, reason: `WeakMap at ${formatPath(path)}` };
+    }
+    if (obj instanceof WeakSet) {
+      return { valid: false, reason: `WeakSet at ${formatPath(path)}` };
+    }
+    if (typeof WeakRef !== "undefined" && obj instanceof WeakRef) {
+      return { valid: false, reason: `WeakRef at ${formatPath(path)}` };
+    }
+
+    // 순환 참조 허용하되 무한루프 방지
+    if (seen.has(obj)) {
+      return { valid: true };
+    }
+    seen.add(obj);
+
+    if (obj instanceof Date) {
+      return { valid: true };
+    }
+    if (obj instanceof ArrayBuffer) {
+      return { valid: true };
+    }
+    if (ArrayBuffer.isView(obj)) {
+      return { valid: true };
+    }
+
+    if (obj instanceof Map) {
+      let i = 0;
+      for (const [k, v] of obj) {
+        const keyResult = isSerializable(k, [...path, `Map.key[${i}]`], seen);
+        if (!keyResult.valid) return keyResult;
+
+        const valResult = isSerializable(v, [...path, `Map.value[${i}]`], seen);
+        if (!valResult.valid) return valResult;
+        i++;
+      }
+      return { valid: true };
+    }
+
+    if (obj instanceof Set) {
+      let i = 0;
+      for (const item of obj) {
+        const result = isSerializable(item, [...path, `Set[${i}]`], seen);
+        if (!result.valid) return result;
+        i++;
+      }
+      return { valid: true };
+    }
+
+    if (Array.isArray(obj)) {
+      for (let i = 0; i < obj.length; i++) {
+        const result = isSerializable(obj[i], [...path, `[${i}]`], seen);
+        if (!result.valid) return result;
+      }
+      return { valid: true };
+    }
+
+    // Vitest는 Error를 허용하지만 속성은 직렬화 필요
+    if (obj instanceof Error) {
+      const errorProps = Object.keys(obj).filter((k) => !["name", "message", "stack"].includes(k));
+      for (const key of errorProps) {
+        const result = isSerializable(
+          (obj as unknown as Record<string, unknown>)[key],
+          [...path, key],
+          seen,
+        );
+        if (!result.valid) return result;
+      }
+      return { valid: true };
+    }
+
+    // Object.prototype 또는 null을 프로토타입으로 가지는 경우만 plain object
+    const proto = Object.getPrototypeOf(obj);
+    if (proto !== Object.prototype && proto !== null) {
+      const constructorName = obj.constructor?.name ?? "Unknown";
+      return {
+        valid: false,
+        reason: `Class instance (${constructorName}) at ${formatPath(path)}`,
+      };
+    }
+
+    for (const key of Object.keys(obj)) {
+      const result = isSerializable((obj as Record<string, unknown>)[key], [...path, key], seen);
+      if (!result.valid) return result;
+    }
+    return { valid: true };
+  }
+
+  return { valid: false, reason: `Unknown type (${type}) at ${formatPath(path)}` };
+}
+
+function formatPath(path: string[]): string {
+  if (path.length === 0) return "(root)";
+  return path.join(".");
+}

package/src/utils/path-utils.ts

@@ -1,4 +1,4 @@
-import { isHotReloadServer } from "./esm-utils.js";
+import { isHotReloadServer, isTest } from "./controller.js";
 
 /**
  * API 패키지 내부 상대 경로 (src/ 또는 dist/로 시작)
@@ -10,7 +10,7 @@ import { isHotReloadServer } from "./esm-utils.js";
  *
  * **기준점**: `Sonamu.apiRootPath` (일반적으로 프로젝트의 `/api` 디렉토리)
  */
-export type ApiRelativePath = `${"src" | "dist"}/${string}` | 'sonamu.config.ts';
+export type ApiRelativePath = `${"src" | "dist"}/${string}` | "sonamu.config.ts";
 
 /**
  * 앱 루트 기준 상대 경로 (api/, web/ 등 타겟 디렉토리로 시작)
@@ -90,10 +90,7 @@ export type AbsolutePath = `/${string}`;
  * @param anyPath
  * @returns
  */
-export function runtimePath(
-  anyPath: string,
-  isDev: boolean = isHotReloadServer()
-): string {
+export function runtimePath(anyPath: string, isDev: boolean = isHotReloadServer() || isTest()): string {
   if (isDev) {
     return anyPath.replace(/dist\//, "src/").replace(/\.js/, ".ts");
   } else {

package/src/utils/process-utils.ts

@@ -17,7 +17,7 @@ export async function runWithGracefulShutdown(
   }: { whenThisHappens: NodeJS.Signals; waitForUpTo: number } = {
     whenThisHappens: "SIGUSR2",
     waitForUpTo: 20000,
-  }
+  },
 ): Promise<void> {
   let isRunning = true as boolean;
 

package/src/utils/sql-parser.ts

@@ -1,5 +1,6 @@
-import * as _ from "lodash-es";
-import { AST, ColumnRef, Expr, ExpressionValue, Select } from "node-sql-parser";
+import type { AST, ColumnRef, Expr, ExpressionValue, From, Join, Select } from "node-sql-parser";
+import { unique } from "radashi";
+import { nonNullable } from "./utils";
 
 export function getTableName(expr: ColumnRef) {
   if ("table" in expr && expr.table !== null) {
@@ -30,11 +31,28 @@ export function getTableNamesFromWhere(ast: AST | AST[]): string[] {
     return [...extractTableName(where.left), ...extractTableName(where.right)];
   };
 
-  return _.uniq(
+  return unique(
     (Array.isArray(ast) ? ast : [ast]).flatMap((a) =>
       a.type === "select" || a.type === "update" || a.type === "delete"
         ? extractTableNames(a.where)
-        : []
-    )
+        : [],
+    ),
+  );
+}
+
+/**
+ * 주의: table명이 아닌 alias를 반환함
+ */
+export function getJoinTables(ast: AST | AST[], joinTypes: Join["join"][]): string[] {
+  const extractJoinTables = (froms: From[]): string[] => {
+    return froms
+      .map((f) => ("join" in f && joinTypes.includes(f.join) ? f.as : null))
+      .filter(nonNullable);
+  };
+
+  return unique(
+    (Array.isArray(ast) ? ast : [ast]).flatMap((a) =>
+      a.type === "select" && Array.isArray(a.from) ? extractJoinTables(a.from) : [],
+    ),
   );
 }

package/src/utils/type-utils.ts

@@ -0,0 +1,83 @@
+// 타입을 펼쳐서 보여주는 유틸리티 (객체에만 사용해야 함)
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+// 핵심 로직
+type SetPath<T, P extends string, V> = T extends readonly (infer U)[] // [Step 1] 현재 타입이 배열인가? -> 요소(U)에 대해 재귀 호출 후 배열로 감쌈
+  ? SetPath<U, P, V>[]
+  : // [Step 2] 경로가 점(.)으로 나뉘는가?
+    P extends `${infer K}.${infer Rest}`
+    ? K extends keyof T
+      ? // [Step 2-1] 키가 존재함
+        Expand<{
+          [Key in keyof T]: Key extends K
+            ? SetPath<T[K], Rest, V> // 재귀 호출
+            : T[Key];
+        }>
+      : // [Step 2-2] 키가 없음 (새로운 객체 경로 생성)
+        Expand<T & { [Key in K]: SetPath<{}, Rest, V> }>
+    : // [Step 3] 경로의 마지막 (Base Case)
+      P extends keyof T
+      ? // [Step 3-1] 기존 키 덮어쓰기 (교차 타입 & 대신 조건부 타입으로 완전 교체)
+        Expand<{ [Key in keyof T]: Key extends P ? V : T[Key] }>
+      : // [Step 3-2] 새 키 추가
+        Expand<T & { [Key in P]: V }>;
+
+export function withProp<T extends object, P extends string, V>(
+  obj: T,
+  path: P,
+  value: V,
+): SetPath<T, P, V> {
+  const keys = path.split(".");
+  if (keys.length === 0) throw new Error("Path cannot be empty");
+  const result = structuredClone(obj);
+
+  const setDeep = (current: any, keys: string[], value: V): void => {
+    if (keys.length === 0) return;
+    const [key, ...rest] = keys;
+
+    if (rest.length === 0) {
+      if (Array.isArray(current)) {
+        current.forEach((item) => {
+          item[key] = value;
+        });
+      } else {
+        current[key] = value;
+      }
+    } else {
+      if (!(key in current) || typeof current[key] !== "object") {
+        current[key] = {};
+      }
+      if (Array.isArray(current[key])) {
+        current[key].forEach((item: any) => {
+          setDeep(item, rest, value);
+        });
+      } else {
+        setDeep(current[key], rest, value);
+      }
+    }
+  };
+
+  setDeep(result, keys, value);
+  return result as SetPath<T, P, V>;
+}
+
+interface ChainWrapper<T> {
+  // 경로에 값을 설정하고 변경된 타입의 새로운 체인 래퍼를 반환합니다.
+  set<P extends string, V>(path: P, value: V): ChainWrapper<SetPath<T, P, V>>;
+
+  // 최종 결과 객체를 반환합니다.
+  value(): T;
+}
+
+/**
+ * 객체를 감싸서 체이닝을 시작합니다.
+ */
+export function withProps<T extends object>(obj: T): ChainWrapper<T> {
+  return {
+    set: <P extends string, V>(path: P, value: V) => {
+      const nextObj = withProp(obj, path, value);
+      return withProps(nextObj) as ChainWrapper<SetPath<T, P, V>>;
+    },
+    value: () => obj,
+  };
+}