sonamu 0.10.12 → 0.10.13

package/src/auth/audit-log-ingestor.ts

@@ -2,8 +2,9 @@ import { createHash } from "node:crypto";
 
 import { type Knex } from "knex";
 
+import { isStringValue } from "../utils/runtime-value";
 import { getValidClientIp } from "./audit-log/client-ip";
-import { type AuditLogEvent } from "./audit-log/events";
+import { type AuditEventData, type AuditLogEvent } from "./audit-log/events";
 
 const AUDIT_EVENT_SOURCE = "better_auth";
 const AUDIT_EVENT_SOURCE_VERSION = "better-auth|@better-auth/infra";
@@ -54,12 +55,12 @@ const USER_EVENT_TYPES = new Set<string>([
   "user_deleted",
 ]);
 
-function pickString(source: Record<string, unknown>, key: string): string | null {
+function pickString(source: AuditEventData, key: string): string | null {
   const value = source[key];
-  return typeof value === "string" ? value : null;
+  return isStringValue(value) ? value : null;
 }
 
-function pickFirstString(source: Record<string, unknown>, keys: readonly string[]): string | null {
+function pickFirstString(source: AuditEventData, keys: readonly string[]): string | null {
   for (const key of keys) {
     const value = pickString(source, key);
     if (value !== null) {
@@ -69,11 +70,11 @@ function pickFirstString(source: Record<string, unknown>, keys: readonly string[
   return null;
 }
 
-function parseOccurredAt(raw: unknown): Date {
+function parseOccurredAt<Value>(raw: Value): Date {
   if (raw instanceof Date && !Number.isNaN(raw.getTime())) {
     return raw;
   }
-  if (typeof raw === "string") {
+  if (isStringValue(raw)) {
     const parsed = new Date(raw);
     if (!Number.isNaN(parsed.getTime())) {
       return parsed;
@@ -120,24 +121,27 @@ function computeDedupeKey(parts: {
   action: string | null;
   occurred_at: Date;
 }): string {
-  const norm = (v: string | null): string => v ?? "";
   const raw = [
     parts.source,
     parts.event_type,
     parts.event_key,
-    norm(parts.actor_user_id),
-    norm(parts.subject_user_id),
-    norm(parts.organization_id),
-    norm(parts.team_id),
-    norm(parts.session_id),
-    norm(parts.identifier),
-    norm(parts.reason),
-    norm(parts.action),
+    normalizeNullableKeyPart(parts.actor_user_id),
+    normalizeNullableKeyPart(parts.subject_user_id),
+    normalizeNullableKeyPart(parts.organization_id),
+    normalizeNullableKeyPart(parts.team_id),
+    normalizeNullableKeyPart(parts.session_id),
+    normalizeNullableKeyPart(parts.identifier),
+    normalizeNullableKeyPart(parts.reason),
+    normalizeNullableKeyPart(parts.action),
     parts.occurred_at.toISOString(),
   ].join("|");
   return createHash("sha256").update(raw).digest("hex");
 }
 
+function normalizeNullableKeyPart(value: string | null): string {
+  return value ?? "";
+}
+
 function computeEventIdDedupeKey(source: string, eventId: string): string {
   return createHash("sha256").update(`${source}|${eventId}`).digest("hex");
 }

package/src/auth/auth-generator.ts

@@ -7,6 +7,10 @@ import { betterAuthV1 } from "./better-auth-entities";
 import { ENTITY_DEFINITIONS, isValidPluginId } from "./plugins/entity-definitions";
 import { type BetterAuthPluginId } from "./plugins/entity-definitions";
 
+interface SubsetFields {
+  [subsetKey: string]: string[];
+}
+
 /**
  * 누락된 props 찾기
  */
@@ -55,10 +59,10 @@ function findMissingIndexes(
  * 누락된 subsets 찾기
  */
 function findMissingSubsets(
-  existingSubsets: { [key: string]: string[] },
-  requiredSubsets: { [key: string]: string[] },
-): { [key: string]: string[] } {
-  const missing: { [key: string]: string[] } = {};
+  existingSubsets: SubsetFields,
+  requiredSubsets: SubsetFields,
+): SubsetFields {
+  const missing: SubsetFields = {};
   for (const [key, fields] of Object.entries(requiredSubsets)) {
     if (!existingSubsets[key]) {
       missing[key] = fields;
@@ -125,7 +129,8 @@ async function createOrUpdateEntity(entityJson: EntityJson): Promise<void> {
   // 누락된 subsets 추가
   const missingSubsets = findMissingSubsets(
     entity.subsets,
-    (entityJson.subsets ?? {}) as { [key: string]: string[] },
+    /* SAFETY: better-auth 훅과 어댑터 계약이 이 값의 타입을 보장한다. */ (entityJson.subsets ??
+      {}) as { [key: string]: string[] },
   );
   for (const [key, fields] of Object.entries(missingSubsets)) {
     entity.subsets[key] = fields;

package/src/auth/better-auth-request.ts

@@ -12,9 +12,10 @@ export function createBetterAuthRequest(
 
   replaceClientIpHeaders(headers, request.ip, ipAddressHeaders);
 
-  return new Request(url.toString(), {
+  const init: RequestInit = {
     method: request.method,
     headers,
-    ...(request.body ? { body: JSON.stringify(request.body) } : {}),
-  });
+  };
+  if (request.body) init.body = JSON.stringify(request.body);
+  return new Request(url.toString(), init);
 }

package/src/auth/knex-adapter.ts

@@ -190,12 +190,18 @@ function applyCondition(
     case "in":
       return query[method === "orWhere" ? "orWhereIn" : "whereIn"](
         field,
-        value as (string | number)[],
+        /* SAFETY: better-auth 훅과 어댑터 계약이 이 값의 타입을 보장한다. */ value as (
+          | string
+          | number
+        )[],
       );
     case "not_in":
       return query[method === "orWhere" ? "orWhereNotIn" : "whereNotIn"](
         field,
-        value as (string | number)[],
+        /* SAFETY: better-auth 훅과 어댑터 계약이 이 값의 타입을 보장한다. */ value as (
+          | string
+          | number
+        )[],
       );
     case "contains":
       return query[method](field, "like", `%${value}%`);

package/src/auth/plugins/entity-definitions/index.ts

@@ -28,7 +28,7 @@ import { usernameEntityDef } from "./username";
  * 엔티티 정의 레지스트리
  * 플러그인 ID로 엔티티 정의에 접근할 수 있습니다.
  */
-export const ENTITY_DEFINITIONS: Record<BetterAuthPluginId, BetterAuthEntityDef> = {
+export const ENTITY_DEFINITIONS = {
   admin: adminEntityDef,
   username: usernameEntityDef,
   "phone-number": phoneNumberEntityDef,
@@ -40,14 +40,15 @@ export const ENTITY_DEFINITIONS: Record<BetterAuthPluginId, BetterAuthEntityDef>
   jwt: jwtEntityDef,
   anonymous: anonymousEntityDef,
   "audit-log": auditLogEntityDef,
-};
+} satisfies Record<BetterAuthPluginId, BetterAuthEntityDef>;
 
 /**
  * 지원하는 플러그인 ID 목록
  */
-export const SUPPORTED_PLUGIN_IDS: BetterAuthPluginId[] = Object.keys(
-  ENTITY_DEFINITIONS,
-) as BetterAuthPluginId[];
+export const SUPPORTED_PLUGIN_IDS: BetterAuthPluginId[] =
+  /* SAFETY: better-auth 훅과 어댑터 계약이 이 값의 타입을 보장한다. */ Object.keys(
+    ENTITY_DEFINITIONS,
+  ) as BetterAuthPluginId[];
 
 /**
  * 플러그인 ID가 유효한지 확인합니다.

package/src/bin/__tests__/http-validator-benchmark.test.ts

@@ -0,0 +1,94 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+
+import { beforeAll, describe, expect, it } from "vitest";
+import { z } from "zod";
+
+const isolatedModeNames = ["cachedPlain", "eagerJit", "aot"] as const;
+type IsolatedModeName = (typeof isolatedModeNames)[number];
+
+const ProcessMetricSchema = z.object({
+  startupMs: z.number(),
+  rssAtStartBytes: z.number(),
+  rssReadyBytes: z.number(),
+});
+
+const ModeRunResultSchema = z.object({
+  mode: z.enum(isolatedModeNames),
+  parity: z.literal(true),
+  fixtureAssertions: z.object({
+    validAccepted: z.literal(true),
+    invalidRejected: z.literal(true),
+  }),
+  process: ProcessMetricSchema,
+  resultChecksum: z.number(),
+});
+
+type ModeRunResult = z.infer<typeof ModeRunResultSchema>;
+
+const packageRoot = path.resolve(import.meta.dirname, "../../..");
+const benchmarkArtifactPath = path.join(packageRoot, "benchmarks/dist/http-validator.bench.mjs");
+
+function parseModeOutput(output: string): ModeRunResult {
+  const outputLine = output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .at(-1);
+  if (outputLine === undefined) {
+    throw new Error("benchmark child process가 결과를 출력하지 않았습니다");
+  }
+  return ModeRunResultSchema.parse(JSON.parse(outputLine));
+}
+
+function runBenchmarkMode(mode: IsolatedModeName): ModeRunResult {
+  const output = execFileSync(process.execPath, [benchmarkArtifactPath], {
+    cwd: packageRoot,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      BENCHMARK_MODE: mode,
+      BENCHMARK_RUN_INDEX: "0",
+      ZOD_COMPILER: undefined,
+    },
+  });
+  return parseModeOutput(output);
+}
+
+describe("HTTP validator benchmark RSS 계약", () => {
+  const results = new Map<IsolatedModeName, ModeRunResult>();
+
+  beforeAll(() => {
+    execFileSync("pnpm", ["exec", "tsdown", "--config", "benchmarks/tsdown.config.ts"], {
+      cwd: packageRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    for (const mode of isolatedModeNames) {
+      results.set(mode, runBenchmarkMode(mode));
+    }
+  }, 120_000);
+
+  it("각 validator mode를 실제 child process로 실행한다", () => {
+    expect([...results.keys()]).toEqual(isolatedModeNames);
+    for (const mode of isolatedModeNames) {
+      expect(results.get(mode)).toMatchObject({
+        mode,
+        parity: true,
+        fixtureAssertions: { validAccepted: true, invalidRejected: true },
+      });
+    }
+  });
+
+  it("각 mode의 시작 및 준비 시점 RSS를 보고한다", () => {
+    for (const mode of isolatedModeNames) {
+      expect(results.get(mode)?.process).toMatchObject({
+        startupMs: expect.any(Number),
+        rssAtStartBytes: expect.any(Number),
+        rssReadyBytes: expect.any(Number),
+      });
+    }
+  });
+});

package/src/bin/__tests__/test-command.test.ts

@@ -1,17 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import { testCommand } from "../test-command";
+
 const originalArgv = process.argv;
 const originalNodeEnv = process.env.NODE_ENV;
 const originalVitest = process.env.VITEST;
-const originalFetch = globalThis.fetch;
 
 // process.argv 파싱 로직을 검증하는 유닛 테스트
 // test-command.ts의 파싱 로직을 동일하게 구현하여 독립 검증
-function parseArgs(args: string[]): {
-  files: string[];
-  pattern: string | undefined;
-  showTraces: boolean;
-} {
+function parseArgs(args: string[]) {
   const files: string[] = [];
   let pattern: string | undefined;
   let showTraces = false;
@@ -91,7 +88,6 @@ describe("test-command argument parsing", () => {
 
 describe("test-command dev server endpoint resolution", () => {
   beforeEach(() => {
-    vi.resetModules();
     vi.restoreAllMocks();
     process.argv = [process.execPath, "sonamu", "test", "--status"];
     process.env.NODE_ENV = "development";
@@ -99,10 +95,8 @@ describe("test-command dev server endpoint resolution", () => {
   });
 
   afterEach(() => {
-    vi.resetModules();
     vi.restoreAllMocks();
     process.argv = originalArgv;
-    globalThis.fetch = originalFetch;
 
     if (originalNodeEnv === undefined) {
       delete process.env.NODE_ENV;
@@ -136,7 +130,7 @@ describe("test-command dev server endpoint resolution", () => {
         },
       };
     });
-    const fetch = vi.fn(async () => {
+    const fetch = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => {
       return new Response(
         JSON.stringify({
           ready: true,
@@ -151,13 +145,13 @@ describe("test-command dev server endpoint resolution", () => {
       );
     });
 
-    vi.doMock("../../api/config", () => ({ loadConfig }));
-    vi.doMock("../../utils/utils", () => ({ findApiRootPath: () => "/tmp/api" }));
     vi.spyOn(console, "log").mockImplementation(() => {});
-    globalThis.fetch = fetch as typeof globalThis.fetch;
 
-    const { testCommand } = await import("../test-command");
-    await testCommand();
+    await testCommand({
+      fetch,
+      findApiRootPath: () => "/tmp/api",
+      loadConfig,
+    });
 
     expect(loadConfig).toHaveBeenCalledWith("/tmp/api");
     expect(fetch).toHaveBeenCalledWith("http://127.0.0.1:4401/__dev_test__/status");

package/src/bin/__tests__/ts-loader-register.test.ts

@@ -1,5 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import { ensureTsLoaderRegistered } from "../ts-loader-registration";
+
 const tsLoaderRegisterStateKey = Symbol.for("sonamu.ts-loader-register.state");
 
 type TsLoaderRegisterState = {
@@ -11,47 +13,43 @@ type GlobalWithTsLoaderRegisterState = typeof globalThis & {
 };
 
 function resetRegisterState() {
-  const globalState = globalThis as GlobalWithTsLoaderRegisterState;
+  const globalState =
+    /* SAFETY: CLI 파서와 빌드 도구 입력 계약이 이 값의 타입을 보장한다. */ globalThis as GlobalWithTsLoaderRegisterState;
   delete globalState[tsLoaderRegisterStateKey];
 }
 
 describe("ensureTsLoaderRegistered", () => {
   beforeEach(() => {
-    vi.resetModules();
     vi.restoreAllMocks();
-    vi.unmock("node:module");
     resetRegisterState();
   });
 
   afterEach(() => {
-    vi.resetModules();
     vi.restoreAllMocks();
-    vi.unmock("node:module");
     resetRegisterState();
   });
 
   it("중복 등록하지 않는다", async () => {
-    const registerMock = vi.fn();
-    vi.doMock("node:module", () => ({
-      register: registerMock,
-    }));
-
-    const module = await import("../ts-loader-registration");
+    const registerFake = vi.fn();
+    const dependencies = {
+      registerLoader: registerFake,
+      resolveLoaderPath: () => "/modules/ts-loader/dist/loader.js",
+    };
 
-    expect(registerMock).not.toHaveBeenCalled();
+    expect(registerFake).not.toHaveBeenCalled();
 
-    await module.ensureTsLoaderRegistered("/tmp/fixture-api");
+    await ensureTsLoaderRegistered("/tmp/fixture-api", dependencies);
 
-    expect(registerMock).toHaveBeenCalledTimes(1);
-    expect(registerMock).toHaveBeenCalledWith(
+    expect(registerFake).toHaveBeenCalledTimes(1);
+    expect(registerFake).toHaveBeenCalledWith(
       expect.stringContaining("/modules/ts-loader/dist/loader.js"),
       {
         parentURL: expect.stringContaining("/src/bin/ts-loader-registration"),
       },
     );
 
-    await module.ensureTsLoaderRegistered("/tmp/another-api");
+    await ensureTsLoaderRegistered("/tmp/another-api", dependencies);
 
-    expect(registerMock).toHaveBeenCalledTimes(1);
+    expect(registerFake).toHaveBeenCalledTimes(1);
   });
 });