sonamu 0.8.24 → 0.8.25

package/dist/bin/ts-loader-register.js

@@ -1,34 +1,8 @@
-import { register } from "node:module";
-import * as path from "node:path";
-import { exists } from "../utils/fs-utils.js";
 import { findApiRootPath } from "../utils/utils.js";
+import { ensureTsLoaderRegistered } from "./ts-loader-registration.js";
 /**
  * @sonamu-kit/ts-loader/loader를 등록하는 스크립트입니다.
  * 이 스크립트는 sonamu cli로 dev 실행할 때 --import로 실행됩니다.
- */ async function setupSwcConfig() {
-    try {
-        const apiRoot = findApiRootPath();
-        // 프로젝트 루트에서 .swcrc 찾기
-        const projectSwcrcPath = path.join(apiRoot, ".swcrc");
-        if (await exists(projectSwcrcPath)) {
-            // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.
-            process.env.SWCRC_PATH = projectSwcrcPath;
-            return;
-        }
-        // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.
-        const sonamuSwcrcPath = path.join(import.meta.dirname, "..", "..", ".swcrc.project-default");
-        if (await exists(sonamuSwcrcPath)) {
-            process.env.SWCRC_PATH = sonamuSwcrcPath;
-            return;
-        }
-    } catch  {
-    // 환경 변수 설정 실패는 무시 (loader가 기본 설정 사용)
-    }
-}
-// swc 설정 파일 경로를 환경 변수로 설정
-await setupSwcConfig();
-register("@sonamu-kit/ts-loader/loader", {
-    parentURL: import.meta.url
-});
+ */ await ensureTsLoaderRegistered(findApiRootPath());
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vdHMtbG9hZGVyLXJlZ2lzdGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGZpbmRBcGlSb290UGF0aCB9IGZyb20gXCIuLi91dGlscy91dGlscy5qc1wiO1xuaW1wb3J0IHsgZW5zdXJlVHNMb2FkZXJSZWdpc3RlcmVkIH0gZnJvbSBcIi4vdHMtbG9hZGVyLXJlZ2lzdHJhdGlvbi5qc1wiO1xuXG4vKipcbiAqIEBzb25hbXUta2l0L3RzLWxvYWRlci9sb2FkZXLrpbwg65Ox66Gd7ZWY64qUIOyKpO2BrOumve2KuOyeheuLiOuLpC5cbiAqIOydtCDsiqTtgazrpr3tirjripQgc29uYW11IGNsaeuhnCBkZXYg7Iuk7ZaJ7ZWgIOuVjCAtLWltcG9ydOuhnCDsi6TtlonrkKnri4jri6QuXG4gKi9cbmF3YWl0IGVuc3VyZVRzTG9hZGVyUmVnaXN0ZXJlZChmaW5kQXBpUm9vdFBhdGgoKSk7XG4iXSwibmFtZXMiOlsiZmluZEFwaVJvb3RQYXRoIiwiZW5zdXJlVHNMb2FkZXJSZWdpc3RlcmVkIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxlQUFlLFFBQVEsb0JBQW9CO0FBQ3BELFNBQVNDLHdCQUF3QixRQUFRLDhCQUE4QjtBQUV2RTs7O0NBR0MsR0FDRCxNQUFNQSx5QkFBeUJEIn0=

package/dist/bin/ts-loader-registration.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureTsLoaderRegistered(apiRoot: string): Promise<void>;
+//# sourceMappingURL=ts-loader-registration.d.ts.map

package/dist/bin/ts-loader-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-loader-registration.d.ts","sourceRoot":"","sources":["../../src/bin/ts-loader-registration.ts"],"names":[],"mappings":"AA0CA,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY7E"}

package/dist/bin/ts-loader-registration.js

@@ -0,0 +1,42 @@
+import { register } from "node:module";
+import * as path from "node:path";
+import { exists } from "../utils/fs-utils.js";
+const tsLoaderRegisterStateKey = Symbol.for("sonamu.ts-loader-register.state");
+function getTsLoaderRegisterState() {
+    const globalState = globalThis;
+    if (!globalState[tsLoaderRegisterStateKey]) {
+        globalState[tsLoaderRegisterStateKey] = {
+            registered: false
+        };
+    }
+    return globalState[tsLoaderRegisterStateKey];
+}
+async function setupSwcConfig(apiRoot) {
+    try {
+        const projectSwcrcPath = path.join(apiRoot, ".swcrc");
+        if (await exists(projectSwcrcPath)) {
+            process.env.SWCRC_PATH = projectSwcrcPath;
+            return;
+        }
+        const sonamuSwcrcPath = path.join(import.meta.dirname, "..", "..", ".swcrc.project-default");
+        if (await exists(sonamuSwcrcPath)) {
+            process.env.SWCRC_PATH = sonamuSwcrcPath;
+            return;
+        }
+    } catch  {
+    // 환경 변수 설정 실패는 무시 (loader가 기본 설정 사용)
+    }
+}
+export async function ensureTsLoaderRegistered(apiRoot) {
+    const state = getTsLoaderRegisterState();
+    if (state.registered) {
+        return;
+    }
+    await setupSwcConfig(apiRoot);
+    register("@sonamu-kit/ts-loader/loader", {
+        parentURL: import.meta.url
+    });
+    state.registered = true;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.8.24",
+  "version": "0.8.25",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -123,10 +123,10 @@
     "tsicli": "^1.0.5",
     "vite": "7.3.0",
     "vitest": "^4.0.10",
-    "@sonamu-kit/hmr-runner": "^0.1.1",
     "@sonamu-kit/hmr-hook": "^0.4.1",
-    "@sonamu-kit/ts-loader": "^2.1.3",
-    "@sonamu-kit/tasks": "^0.2.0"
+    "@sonamu-kit/tasks": "^0.2.0",
+    "@sonamu-kit/hmr-runner": "^0.1.1",
+    "@sonamu-kit/ts-loader": "^2.1.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.13",

package/src/api/__tests__/config.test.ts

@@ -0,0 +1,225 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const tsLoaderRegisterStateKey = Symbol.for("sonamu.ts-loader-register.state");
+
+type TsLoaderRegisterState = {
+  registered: boolean;
+};
+
+type GlobalWithTsLoaderRegisterState = typeof globalThis & {
+  [tsLoaderRegisterStateKey]?: TsLoaderRegisterState;
+};
+
+function resetRegisterState() {
+  const globalState = globalThis as GlobalWithTsLoaderRegisterState;
+  delete globalState[tsLoaderRegisterStateKey];
+  delete process.env.SWCRC_PATH;
+}
+
+async function createTempRoot(): Promise<string> {
+  return mkdtemp(path.join(os.tmpdir(), "sonamu-config-test-"));
+}
+
+async function writeSourceFixture(rootPath: string): Promise<void> {
+  await mkdir(path.join(rootPath, "src"), { recursive: true });
+  await writeFile(
+    path.join(rootPath, "src", "support.ts"),
+    `
+export const fastifyOptions = { keepAliveTimeout: 4321 };
+export function customPlugin() {
+  return "plugin";
+}
+export function contextProvider(defaultContext) {
+  return defaultContext;
+}
+export function guardHandler() {}
+`,
+  );
+  await writeFile(
+    path.join(rootPath, "src", "sonamu.config.ts"),
+    `
+import { customPlugin, contextProvider, fastifyOptions, guardHandler } from "./support";
+
+export default {
+  api: {
+    dir: "./src",
+    route: {
+      prefix: "/api",
+    },
+  },
+  i18n: {
+    defaultLocale: "ko",
+    supportedLocales: ["ko"],
+  },
+  sync: {
+    targets: ["web"],
+  },
+  server: {
+    fastify: fastifyOptions,
+    plugins: {
+      custom: customPlugin,
+    },
+    apiConfig: {
+      contextProvider,
+      guardHandler,
+    },
+  },
+  test: {
+    parallel: true,
+    maxWorkers: 3,
+    devRunner: {
+      enabled: true,
+      routePrefix: "/__test__",
+    },
+  },
+};
+`,
+  );
+}
+
+async function writeDistFixture(rootPath: string): Promise<void> {
+  await mkdir(path.join(rootPath, "dist"), { recursive: true });
+  await writeFile(
+    path.join(rootPath, "dist", "sonamu.config.js"),
+    `
+export default {
+  api: {
+    dir: "./dist",
+    route: {
+      prefix: "/api",
+    },
+  },
+  i18n: {
+    defaultLocale: "en",
+    supportedLocales: ["en"],
+  },
+  sync: {
+    targets: ["web"],
+  },
+  server: {
+    apiConfig: {
+      contextProvider(defaultContext) {
+        return defaultContext;
+      },
+      guardHandler() {},
+    },
+  },
+  test: {
+    devRunner: {
+      enabled: false,
+    },
+  },
+};
+`,
+  );
+}
+
+describe("loadConfig", () => {
+  const tempRoots: string[] = [];
+  const originalHot = process.env.HOT;
+  const originalVitest = process.env.VITEST;
+  const originalSwcrcPath = process.env.SWCRC_PATH;
+
+  beforeEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    vi.unmock("../../bin/ts-loader-registration");
+    resetRegisterState();
+  });
+
+  afterEach(async () => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    vi.unmock("../../bin/ts-loader-registration");
+    resetRegisterState();
+
+    if (originalHot === undefined) {
+      delete process.env.HOT;
+    } else {
+      process.env.HOT = originalHot;
+    }
+
+    if (originalVitest === undefined) {
+      delete process.env.VITEST;
+    } else {
+      process.env.VITEST = originalVitest;
+    }
+
+    if (originalSwcrcPath === undefined) {
+      delete process.env.SWCRC_PATH;
+    } else {
+      process.env.SWCRC_PATH = originalSwcrcPath;
+    }
+
+    await Promise.all(
+      tempRoots.splice(0).map((rootPath) => rm(rootPath, { recursive: true, force: true })),
+    );
+  });
+
+  it("source config 로드 전에 ts-loader 등록을 보장한다", async () => {
+    const rootPath = await createTempRoot();
+    tempRoots.push(rootPath);
+    await writeSourceFixture(rootPath);
+
+    process.env.VITEST = "true";
+    const ensureTsLoaderRegistered = vi.fn(async () => {});
+    vi.doMock("../../bin/ts-loader-registration", () => ({
+      ensureTsLoaderRegistered,
+    }));
+
+    const { loadConfig } = await import("../config");
+    const config = await loadConfig(rootPath);
+
+    expect(ensureTsLoaderRegistered).toHaveBeenCalledTimes(1);
+    expect(ensureTsLoaderRegistered).toHaveBeenCalledWith(rootPath);
+    expect(config.test?.devRunner?.enabled).toBe(true);
+  });
+
+  it("dist config 로딩 경로는 기존과 동일하게 유지한다", async () => {
+    const rootPath = await createTempRoot();
+    tempRoots.push(rootPath);
+    await writeDistFixture(rootPath);
+
+    delete process.env.HOT;
+    delete process.env.VITEST;
+    const ensureTsLoaderRegistered = vi.fn(async () => {});
+    vi.doMock("../../bin/ts-loader-registration", () => ({
+      ensureTsLoaderRegistered,
+    }));
+
+    const { loadConfig } = await import("../config");
+    const config = await loadConfig(rootPath);
+
+    expect(ensureTsLoaderRegistered).not.toHaveBeenCalled();
+    expect(config.api.dir).toBe("./dist");
+    expect(config.test?.devRunner?.enabled).toBe(false);
+  });
+
+  it("source config가 확장자 없는 상대 import와 런타임 객체를 유지하며 반복 로드된다", async () => {
+    const rootPath = await createTempRoot();
+    tempRoots.push(rootPath);
+    await writeSourceFixture(rootPath);
+
+    process.env.VITEST = "true";
+    vi.unmock("../../bin/ts-loader-registration");
+    const { loadConfig } = await import("../config");
+    const supportModule = await import(
+      pathToFileURL(path.join(rootPath, "src", "support.ts")).href
+    );
+
+    const firstConfig = await loadConfig(rootPath);
+    const secondConfig = await loadConfig(rootPath);
+
+    expect(firstConfig.server.fastify).toBe(supportModule.fastifyOptions);
+    expect(firstConfig.server.plugins?.custom).toBe(supportModule.customPlugin);
+    expect(firstConfig.test?.parallel).toBe(true);
+    expect(firstConfig.test?.maxWorkers).toBe(3);
+    expect(firstConfig.test?.devRunner?.enabled).toBe(true);
+    expect(secondConfig.server.plugins?.custom).toBe(supportModule.customPlugin);
+    expect(secondConfig.server.fastify).toBe(supportModule.fastifyOptions);
+  });
+});

package/src/api/config.ts

@@ -289,10 +289,16 @@ export function defineConfig(config: Executable<SonamuConfig>): Promise<SonamuCo
  */
 export async function loadConfig(rootPath: string): Promise<SonamuConfig> {
   const start = performance.now();
-  const configPath =
-    process.env.HOT === "yes" || process.env.VITEST === "true"
-      ? `${rootPath}/src/sonamu.config.ts`
-      : `${rootPath}/dist/sonamu.config.js`;
+  const shouldLoadSourceConfig = process.env.HOT === "yes" || process.env.VITEST === "true";
+  const configPath = shouldLoadSourceConfig
+    ? `${rootPath}/src/sonamu.config.ts`
+    : `${rootPath}/dist/sonamu.config.js`;
+
+  if (shouldLoadSourceConfig) {
+    const { ensureTsLoaderRegistered } = await import("../bin/ts-loader-registration");
+    await ensureTsLoaderRegistered(rootPath);
+  }
+
   const { default: config } = await import(`file://${configPath}`);
   const importTime = performance.now() - start;
   process.env.NODE_ENV !== "test" &&

package/src/api/sonamu.ts

@@ -9,7 +9,6 @@ import type { IncomingMessage, Server, ServerResponse } from "http";
 import mime, { lookup as mimeLookup } from "mime-types";
 import os from "os";
 import path from "path";
-import type { PoolConfig } from "pg";
 import type { ZodObject } from "zod";
 import {
   BASE_FIELD_MAPPINGS,
@@ -232,6 +231,22 @@ class SonamuClass {
     // Cache 초기화
     await this.initializeCache(this.config.server.cache, forTesting);
 
+    // BetterAuth 초기화
+    const authConfig = this.config.server.auth;
+    if (authConfig) {
+      // 사용자 설정과 기본값을 merge
+      const mergedFieldMappings = merge(BASE_FIELD_MAPPINGS, authConfig);
+
+      // better-auth 인스턴스 생성
+      const { betterAuth } = await import("better-auth");
+      const { sonamuKnexAdapter } = await import("../auth/knex-adapter");
+
+      this._auth = betterAuth({
+        database: sonamuKnexAdapter(),
+        ...mergedFieldMappings,
+      });
+    }
+
     // 테스팅인 경우 싱크 없이 중단
     if (forTesting) {
       this.isInitialized = true;
@@ -1243,18 +1258,6 @@ class SonamuClass {
 
     const basePath = options.basePath ?? "/api/auth";
 
-    // 사용자 설정과 기본값을 merge
-    const mergedFieldMappings = merge(BASE_FIELD_MAPPINGS, options);
-
-    // better-auth 인스턴스 생성
-    const { betterAuth } = await import("better-auth");
-    const { Pool } = await import("pg");
-
-    this._auth = betterAuth({
-      database: new Pool(DB.getDBConfig("w").connection as PoolConfig),
-      ...mergedFieldMappings,
-    });
-
     // better-auth 라우트 등록
     server.route({
       method: ["GET", "POST"],

package/src/auth/index.ts

@@ -1,6 +1,7 @@
 export type { GenerateBetterAuthEntitiesOptions } from "./auth-generator";
 export { generateBetterAuthEntities } from "./auth-generator";
 export { BASE_FIELD_MAPPINGS, betterAuthV1 } from "./better-auth-entities";
+export { sonamuKnexAdapter } from "./knex-adapter";
 
 // 외부로는 wrappers만 export (admin, twoFactor 등 래퍼 함수와 SCHEMA)
 export * from "./plugins";

package/src/auth/knex-adapter.ts

@@ -0,0 +1,207 @@
+import type { BetterAuthOptions } from "better-auth";
+import type {
+  AdapterFactoryCustomizeAdapterCreator,
+  DBTransactionAdapter,
+} from "better-auth/adapters";
+import { createAdapterFactory } from "better-auth/adapters";
+import type { Knex } from "knex";
+import { DB } from "../database/db";
+
+interface CleanedWhere {
+  field: string;
+  value: string | number | boolean | string[] | number[] | Date | null;
+  operator: string;
+  connector: string;
+}
+
+/**
+ * better-auth용 Sonamu knex 어댑터
+ *
+ * better-auth의 모든 쿼리를 DB.getDB()를 통해 실행하여
+ * Sonamu 테스트 트랜잭션과 동일한 커넥션을 공유합니다.
+ */
+export const sonamuKnexAdapter = () => {
+  let lazyOptions: BetterAuthOptions | null = null;
+
+  const createCustomAdapter = (
+    getDb: () => Knex | Knex.Transaction,
+  ): AdapterFactoryCustomizeAdapterCreator => {
+    return () => ({
+      create: async ({ model, data }) => {
+        const [row] = await getDb()(model).insert(data).returning("*");
+        return row;
+      },
+
+      findOne: async ({ model, where }) => {
+        let query = getDb()(model);
+        query = applyWhere(query, where);
+        const row = await query.first();
+        return row ?? null;
+      },
+
+      findMany: async ({ model, where, limit, offset, sortBy }) => {
+        let query = getDb()(model);
+        if (where) {
+          query = applyWhere(query, where);
+        }
+        if (sortBy) {
+          query = query.orderBy(sortBy.field, sortBy.direction);
+        }
+        if (limit) {
+          query = query.limit(limit);
+        }
+        if (offset) {
+          query = query.offset(offset);
+        }
+        return await query;
+      },
+
+      update: async ({ model, where, update }) => {
+        let query = getDb()(model);
+        query = applyWhere(query, where);
+        const [row] = await query.update(update).returning("*");
+        return row ?? null;
+      },
+
+      updateMany: async ({ model, where, update }) => {
+        let query = getDb()(model);
+        query = applyWhere(query, where);
+        const count = await query.update(update);
+        return count;
+      },
+
+      delete: async ({ model, where }) => {
+        let query = getDb()(model);
+        query = applyWhere(query, where);
+        await query.del();
+      },
+
+      deleteMany: async ({ model, where }) => {
+        let query = getDb()(model);
+        query = applyWhere(query, where);
+        const count = await query.del();
+        return count;
+      },
+
+      count: async ({ model, where }) => {
+        let query = getDb()(model);
+        if (where) {
+          query = applyWhere(query, where);
+        }
+        const [{ count }] = await query.count("* as count");
+        return Number(count);
+      },
+    });
+  };
+
+  const adapterConfig = {
+    adapterId: "sonamu-knex",
+    adapterName: "Sonamu Knex Adapter",
+    usePlural: false,
+    supportsJSON: true,
+    supportsDates: true,
+    supportsBooleans: true,
+    supportsNumericIds: false,
+    transaction: async <R>(cb: (trx: DBTransactionAdapter) => Promise<R>): Promise<R> => {
+      const db = DB.getDB("w");
+      return db.transaction(async (trx) => {
+        const options = lazyOptions;
+        if (!options) {
+          throw new Error("sonamuKnexAdapter: options not initialized");
+        }
+        return cb(
+          createAdapterFactory({
+            config: adapterConfig,
+            adapter: createCustomAdapter(() => trx),
+          })(options),
+        );
+      });
+    },
+  };
+
+  const adapterCreator = createAdapterFactory({
+    config: adapterConfig,
+    adapter: createCustomAdapter(() => DB.getDB("w")),
+  });
+
+  return (options: BetterAuthOptions) => {
+    lazyOptions = options;
+    return adapterCreator(options);
+  };
+};
+
+/**
+ * Better Auth의 공식 어댑터(Kysely, Drizzle, Prisma, MongoDB) 패턴에 맞춰
+ * AND 그룹과 OR 그룹을 분리한 뒤 top-level AND로 결합합니다.
+ * 결과: (A AND B AND ...) AND (C OR D OR ...)
+ */
+export function applyWhere(
+  query: Knex.QueryBuilder,
+  conditions: CleanedWhere[],
+): Knex.QueryBuilder {
+  const andGroup = conditions.filter((c) => c.connector !== "OR");
+  const orGroup = conditions.filter((c) => c.connector === "OR");
+
+  if (andGroup.length > 0) {
+    for (const condition of andGroup) {
+      query = applyCondition(query, condition, "where");
+    }
+  }
+
+  if (orGroup.length > 0) {
+    query = query.where(function (this: Knex.QueryBuilder) {
+      for (let i = 0; i < orGroup.length; i++) {
+        applyCondition(this, orGroup[i], i === 0 ? "where" : "orWhere");
+      }
+    });
+  }
+
+  return query;
+}
+
+function applyCondition(
+  query: Knex.QueryBuilder,
+  condition: CleanedWhere,
+  method: "where" | "orWhere",
+): Knex.QueryBuilder {
+  const { field, value, operator } = condition;
+
+  switch (operator) {
+    case "eq":
+      if (value === null) {
+        return query[method === "orWhere" ? "orWhereNull" : "whereNull"](field);
+      }
+      return query[method](field, "=", value);
+    case "ne":
+      if (value === null) {
+        return query[method === "orWhere" ? "orWhereNotNull" : "whereNotNull"](field);
+      }
+      return query[method](field, "!=", value);
+    case "lt":
+      return query[method](field, "<", value);
+    case "lte":
+      return query[method](field, "<=", value);
+    case "gt":
+      return query[method](field, ">", value);
+    case "gte":
+      return query[method](field, ">=", value);
+    case "in":
+      return query[method === "orWhere" ? "orWhereIn" : "whereIn"](
+        field,
+        value as (string | number)[],
+      );
+    case "not_in":
+      return query[method === "orWhere" ? "orWhereNotIn" : "whereNotIn"](
+        field,
+        value as (string | number)[],
+      );
+    case "contains":
+      return query[method](field, "like", `%${value}%`);
+    case "starts_with":
+      return query[method](field, "like", `${value}%`);
+    case "ends_with":
+      return query[method](field, "like", `%${value}`);
+    default:
+      return query;
+  }
+}