@gencow/core 0.1.23 → 0.1.25

package/src/retry.ts

@@ -29,18 +29,18 @@
 // ─── 타입 ───────────────────────────────────────────────
 
 export interface RetryOptions {
-    /** 최대 시도 횟수 (기본 3) */
-    maxAttempts?: number;
-    /** 첫 번째 재시도 대기 시간 (ms, 기본 1000) */
-    initialBackoffMs?: number;
-    /** backoff 배수 (기본 2 → 1s, 2s, 4s, 8s, ...) */
-    base?: number;
-    /** 최대 대기 시간 (ms, 기본 30000) */
-    maxBackoffMs?: number;
-    /** 재시도할 에러인지 판단 (기본: 모든 에러 재시도) */
-    shouldRetry?: (error: unknown, attempt: number) => boolean;
-    /** 재시도 시 호출되는 콜백 (로깅용) */
-    onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
+  /** 최대 시도 횟수 (기본 3) */
+  maxAttempts?: number;
+  /** 첫 번째 재시도 대기 시간 (ms, 기본 1000) */
+  initialBackoffMs?: number;
+  /** backoff 배수 (기본 2 → 1s, 2s, 4s, 8s, ...) */
+  base?: number;
+  /** 최대 대기 시간 (ms, 기본 30000) */
+  maxBackoffMs?: number;
+  /** 재시도할 에러인지 판단 (기본: 모든 에러 재시도) */
+  shouldRetry?: (error: unknown, attempt: number) => boolean;
+  /** 재시도 시 호출되는 콜백 (로깅용) */
+  onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
 }
 
 // ─── 기본값 ─────────────────────────────────────────────
@@ -60,53 +60,50 @@ const JITTER_MAX = 1.25;
  * Exponential backoff + jitter로 재시도.
  * delay = min(initialBackoffMs × base^attempt × jitter, maxBackoffMs)
  */
-export async function withRetry<T>(
-    fn: () => Promise<T>,
-    options: RetryOptions = {},
-): Promise<T> {
-    const {
-        maxAttempts = DEFAULT_MAX_ATTEMPTS,
-        initialBackoffMs = DEFAULT_INITIAL_BACKOFF_MS,
-        base = DEFAULT_BASE,
-        maxBackoffMs = DEFAULT_MAX_BACKOFF_MS,
-        shouldRetry,
-        onRetry,
-    } = options;
-
-    if (maxAttempts < 1) {
-        throw new Error(`withRetry: maxAttempts must be >= 1, got ${maxAttempts}`);
+export async function withRetry<T>(fn: () => Promise<T>, options: RetryOptions = {}): Promise<T> {
+  const {
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    initialBackoffMs = DEFAULT_INITIAL_BACKOFF_MS,
+    base = DEFAULT_BASE,
+    maxBackoffMs = DEFAULT_MAX_BACKOFF_MS,
+    shouldRetry,
+    onRetry,
+  } = options;
+
+  if (maxAttempts < 1) {
+    throw new Error(`withRetry: maxAttempts must be >= 1, got ${maxAttempts}`);
+  }
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error: unknown) {
+      const isLastAttempt = attempt === maxAttempts - 1;
+
+      // 마지막 시도면 에러 throw
+      if (isLastAttempt) throw error;
+
+      // shouldRetry가 있으면 판단
+      if (shouldRetry && !shouldRetry(error, attempt)) throw error;
+
+      // 딜레이 계산: exponential backoff + jitter
+      const jitter = JITTER_MIN + Math.random() * (JITTER_MAX - JITTER_MIN);
+      const rawDelay = initialBackoffMs * Math.pow(base, attempt) * jitter;
+      const delay = Math.min(rawDelay, maxBackoffMs);
+
+      // 콜백 호출
+      if (onRetry) onRetry(error, attempt + 1, delay);
+
+      await sleep(delay);
     }
+  }
 
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        try {
-            return await fn();
-        } catch (error: unknown) {
-            const isLastAttempt = attempt === maxAttempts - 1;
-
-            // 마지막 시도면 에러 throw
-            if (isLastAttempt) throw error;
-
-            // shouldRetry가 있으면 판단
-            if (shouldRetry && !shouldRetry(error, attempt)) throw error;
-
-            // 딜레이 계산: exponential backoff + jitter
-            const jitter = JITTER_MIN + Math.random() * (JITTER_MAX - JITTER_MIN);
-            const rawDelay = initialBackoffMs * Math.pow(base, attempt) * jitter;
-            const delay = Math.min(rawDelay, maxBackoffMs);
-
-            // 콜백 호출
-            if (onRetry) onRetry(error, attempt + 1, delay);
-
-            await sleep(delay);
-        }
-    }
-
-    // TypeScript를 위한 unreachable — 실제로 여기에 도달하지 않음
-    throw new Error("withRetry: unreachable");
+  // TypeScript를 위한 unreachable — 실제로 여기에 도달하지 않음
+  throw new Error("withRetry: unreachable");
 }
 
 // ─── 내부 유틸리티 ──────────────────────────────────────
 
 function sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/rls-db.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { sql } from "drizzle-orm";
-import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { PgAsyncDatabase } from "drizzle-orm/pg-core";
 
 /**
  * RLS DB wrapper — execution paths for `withRlsConnection`:
@@ -15,66 +15,62 @@ import type { PgDatabase } from "drizzle-orm/pg-core";
  * Optional fields become `app.*` settings; add arbitrary allowed keys via `vars`.
  */
 export type RlsSessionContext = {
-    /** `app.current_user_id` — required by `ownerRls()` policies in this repo. */
-    userId: string;
-    /** When set: `app.current_user_role`. */
-    role?: string;
-    /** When set: `app.tenant_id`. */
-    tenantId?: string;
-    /**
-     * Extra transaction-local settings: keys must be validated `app.*` GUC names
-     * and must not duplicate `app.current_user_id` / `app.current_user_role` / `app.tenant_id`
-     * (use the top-level fields for those).
-     */
-    vars?: Record<string, string>;
+  /** `app.current_user_id` — required by `ownerRls()` policies in this repo. */
+  userId: string;
+  /** When set: `app.current_user_role`. */
+  role?: string;
+  /** When set: `app.tenant_id`. */
+  tenantId?: string;
+  /**
+   * Extra transaction-local settings: keys must be validated `app.*` GUC names
+   * and must not duplicate `app.current_user_id` / `app.current_user_role` / `app.tenant_id`
+   * (use the top-level fields for those).
+   */
+  vars?: Record<string, string>;
 };
 
 const gucNameRe = /^app\.[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/;
 
-const RESERVED_VARS_KEYS = new Set([
-    "app.current_user_id",
-    "app.current_user_role",
-    "app.tenant_id",
-]);
+const RESERVED_VARS_KEYS = new Set(["app.current_user_id", "app.current_user_role", "app.tenant_id"]);
 
 function assertSafeGucName(key: string): void {
-    if (!gucNameRe.test(key)) {
-        throw new Error(
-            `createRlsDb: GUC name "${key}" is invalid — use lowercase app.* names (e.g. app.org_id)`,
-        );
-    }
+  if (!gucNameRe.test(key)) {
+    throw new Error(
+      `createRlsDb: GUC name "${key}" is invalid — use lowercase app.* names (e.g. app.org_id)`,
+    );
+  }
 }
 
 /** Ordered `(name, value)` pairs for `set_config(name, value, true)`. */
 function rlsSetConfigPairs(rls: RlsSessionContext): [string, string][] {
-    const pairs: [string, string][] = [["app.current_user_id", rls.userId]];
-    if (rls.role !== undefined) {
-        pairs.push(["app.current_user_role", rls.role]);
-    }
-    if (rls.tenantId !== undefined) {
-        pairs.push(["app.tenant_id", rls.tenantId]);
-    }
-    if (rls.vars) {
-        for (const [key, value] of Object.entries(rls.vars)) {
-            assertSafeGucName(key);
-            if (RESERVED_VARS_KEYS.has(key)) {
-                throw new Error(
-                    `createRlsDb: vars must not set "${key}" — use userId, role, or tenantId on the context object`,
-                );
-            }
-            pairs.push([key, value]);
-        }
+  const pairs: [string, string][] = [["app.current_user_id", rls.userId]];
+  if (rls.role !== undefined) {
+    pairs.push(["app.current_user_role", rls.role]);
+  }
+  if (rls.tenantId !== undefined) {
+    pairs.push(["app.tenant_id", rls.tenantId]);
+  }
+  if (rls.vars) {
+    for (const [key, value] of Object.entries(rls.vars)) {
+      assertSafeGucName(key);
+      if (RESERVED_VARS_KEYS.has(key)) {
+        throw new Error(
+          `createRlsDb: vars must not set "${key}" — use userId, role, or tenantId on the context object`,
+        );
+      }
+      pairs.push([key, value]);
     }
-    return pairs;
+  }
+  return pairs;
 }
 
 async function forEachSetConfig(
-    rls: RlsSessionContext,
-    setOne: (name: string, value: string) => Promise<void>,
+  rls: RlsSessionContext,
+  setOne: (name: string, value: string) => Promise<void>,
 ): Promise<void> {
-    for (const [name, value] of rlsSetConfigPairs(rls)) {
-        await setOne(name, value);
-    }
+  for (const [name, value] of rlsSetConfigPairs(rls)) {
+    await setOne(name, value);
+  }
 }
 
 /**
@@ -83,36 +79,32 @@ async function forEachSetConfig(
 const rlsExecClient = new AsyncLocalStorage<unknown>();
 
 function isDrizzleTransactionDb(db: unknown): boolean {
-    const d = db as { constructor?: { name?: string }; rollback?: unknown };
-    if (typeof d?.rollback === "function") {
-        return true;
-    }
-    const name = d?.constructor?.name;
-    return typeof name === "string" && name.includes("Transaction");
+  const d = db as { constructor?: { name?: string }; rollback?: unknown };
+  if (typeof d?.rollback === "function") {
+    return true;
+  }
+  const name = d?.constructor?.name;
+  return typeof name === "string" && name.includes("Transaction");
 }
 
 async function execSetConfig(client: any, name: string, value: string): Promise<void> {
-    if (typeof client?.unsafe === "function") {
-        await client.unsafe(`select set_config($1::text, $2::text, true)`, [name, value]);
-        return;
-    }
-    if (typeof client?.query === "function") {
-        await client.query(`select set_config($1::text, $2::text, true)`, [name, value]);
-        return;
-    }
-    throw new Error(
-        "createRlsDb: unsupported SQL driver (expected Bun SQL, node-pg client/pool, or PGlite)",
-    );
+  if (typeof client?.unsafe === "function") {
+    await client.unsafe(`select set_config($1::text, $2::text, true)`, [name, value]);
+    return;
+  }
+  if (typeof client?.query === "function") {
+    await client.query(`select set_config($1::text, $2::text, true)`, [name, value]);
+    return;
+  }
+  throw new Error("createRlsDb: unsupported SQL driver (expected Bun SQL, node-pg client/pool, or PGlite)");
 }
 
 async function applyRlsSessionVars(client: any, rls: RlsSessionContext): Promise<void> {
-    await forEachSetConfig(rls, (name, value) => execSetConfig(client, name, value));
+  await forEachSetConfig(rls, (name, value) => execSetConfig(client, name, value));
 }
 
 async function injectRlsVarsOnTx(tx: any, rls: RlsSessionContext): Promise<void> {
-    await forEachSetConfig(rls, (name, value) =>
-        tx.execute(sql`SELECT set_config(${name}, ${value}, true)`),
-    );
+  await forEachSetConfig(rls, (name, value) => tx.execute(sql`SELECT set_config(${name}, ${value}, true)`));
 }
 
 /**
@@ -122,26 +114,26 @@ async function injectRlsVarsOnTx(tx: any, rls: RlsSessionContext): Promise<void>
  * @internal Exported only for unit tests — not re-exported from `@gencow/core` public API.
  */
 export async function withRlsLeasedConnection<T>(
-    leased: { query: (sql: string) => Promise<unknown>; release: () => void },
-    rls: RlsSessionContext,
-    fn: (client: { query: (sql: string) => Promise<unknown>; release: () => void }) => Promise<T>,
+  leased: { query: (sql: string) => Promise<unknown>; release: () => void },
+  rls: RlsSessionContext,
+  fn: (client: { query: (sql: string) => Promise<unknown>; release: () => void }) => Promise<T>,
 ): Promise<T> {
+  try {
+    await leased.query("begin");
+    await applyRlsSessionVars(leased, rls);
+    const result = await rlsExecClient.run(leased, () => fn(leased));
+    await leased.query("commit");
+    return result;
+  } catch (e) {
     try {
-        await leased.query("begin");
-        await applyRlsSessionVars(leased, rls);
-        const result = await rlsExecClient.run(leased, () => fn(leased));
-        await leased.query("commit");
-        return result;
-    } catch (e) {
-        try {
-            await leased.query("rollback");
-        } catch {
-            /* ignore */
-        }
-        throw e;
-    } finally {
-        leased.release();
+      await leased.query("rollback");
+    } catch {
+      /* ignore */
     }
+    throw e;
+  } finally {
+    leased.release();
+  }
 }
 
 /**
@@ -150,104 +142,99 @@ export async function withRlsLeasedConnection<T>(
  * When `db` is already a Drizzle transaction object, reuses that connection (no nested top-level tx).
  */
 async function withRlsConnection<T>(
-    session: any,
-    rls: RlsSessionContext,
-    reuseOuterConnection: boolean,
-    fn: (client: any) => Promise<T>,
+  session: any,
+  rls: RlsSessionContext,
+  reuseOuterConnection: boolean,
+  fn: (client: any) => Promise<T>,
 ): Promise<T> {
-    if (reuseOuterConnection) {
-        const c = session.client;
-        return rlsExecClient.run(c, async () => {
-            await applyRlsSessionVars(c, rls);
-            return fn(c);
-        });
-    }
+  if (reuseOuterConnection) {
     const c = session.client;
-    const runInner = async (client: any) => {
-        await applyRlsSessionVars(client, rls);
-        return rlsExecClient.run(client, () => fn(client));
-    };
-    if (typeof c.begin === "function") {
-        return c.begin(runInner);
-    }
-    if (typeof c.transaction === "function") {
-        return c.transaction(runInner);
-    }
-    if (typeof c.connect === "function" && typeof c.query === "function") {
-        const leased = await c.connect();
-        return withRlsLeasedConnection(leased, rls, fn);
-    }
-    return runInner(c);
+    return rlsExecClient.run(c, async () => {
+      await applyRlsSessionVars(c, rls);
+      return fn(c);
+    });
+  }
+  const c = session.client;
+  const runInner = async (client: any) => {
+    await applyRlsSessionVars(client, rls);
+    return rlsExecClient.run(client, () => fn(client));
+  };
+  if (typeof c.begin === "function") {
+    return c.begin(runInner);
+  }
+  if (typeof c.transaction === "function") {
+    return c.transaction(runInner);
+  }
+  if (typeof c.connect === "function" && typeof c.query === "function") {
+    const leased = await c.connect();
+    return withRlsLeasedConnection(leased, rls, fn);
+  }
+  return runInner(c);
 }
 
-function wrapPreparedQuery(
-    pq: any,
-    session: any,
-    rls: RlsSessionContext,
-    reuseOuterConnection: boolean,
-) {
-    const origExecute = pq.execute.bind(pq);
-    const origAll = pq.all.bind(pq);
+function wrapPreparedQuery(pq: any, session: any, rls: RlsSessionContext, reuseOuterConnection: boolean) {
+  const origExecute = pq.execute.bind(pq);
+  const origAll = pq.all.bind(pq);
 
-    pq.execute = async (placeholderValues?: unknown) => {
-        const active = rlsExecClient.getStore();
-        if (active) {
-            const prev = pq.client;
-            pq.client = active;
-            try {
-                return await origExecute(placeholderValues);
-            } finally {
-                pq.client = prev;
-            }
-        }
-        return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-            const prev = pq.client;
-            pq.client = client;
-            try {
-                return await origExecute(placeholderValues);
-            } finally {
-                pq.client = prev;
-            }
-        });
-    };
+  pq.execute = async (placeholderValues?: unknown) => {
+    const active = rlsExecClient.getStore();
+    if (active) {
+      const prev = pq.client;
+      pq.client = active;
+      try {
+        return await origExecute(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    }
+    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+      const prev = pq.client;
+      pq.client = client;
+      try {
+        return await origExecute(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    });
+  };
 
-    pq.all = async (placeholderValues?: unknown) => {
-        const active = rlsExecClient.getStore();
-        if (active) {
-            const prev = pq.client;
-            pq.client = active;
-            try {
-                return await origAll(placeholderValues);
-            } finally {
-                pq.client = prev;
-            }
-        }
-        return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-            const prev = pq.client;
-            pq.client = client;
-            try {
-                return await origAll(placeholderValues);
-            } finally {
-                pq.client = prev;
-            }
-        });
-    };
+  pq.all = async (placeholderValues?: unknown) => {
+    const active = rlsExecClient.getStore();
+    if (active) {
+      const prev = pq.client;
+      pq.client = active;
+      try {
+        return await origAll(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    }
+    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+      const prev = pq.client;
+      pq.client = client;
+      try {
+        return await origAll(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    });
+  };
 }
 
 function wrapSession(session: any, rls: RlsSessionContext, reuseOuterConnection: boolean) {
-    return new Proxy(session, {
-        get(sTarget, sProp, sRecv) {
-            if (sProp === "prepareQuery") {
-                return (...args: unknown[]) => {
-                    const pq = sTarget.prepareQuery(...args);
-                    wrapPreparedQuery(pq, sTarget, rls, reuseOuterConnection);
-                    return pq;
-                };
-            }
-            const v = Reflect.get(sTarget, sProp, sRecv);
-            return typeof v === "function" ? v.bind(sTarget) : v;
-        },
-    });
+  return new Proxy(session, {
+    get(sTarget, sProp, sRecv) {
+      if (sProp === "prepareQuery") {
+        return (...args: unknown[]) => {
+          const pq = sTarget.prepareQuery(...args);
+          wrapPreparedQuery(pq, sTarget, rls, reuseOuterConnection);
+          return pq;
+        };
+      }
+      const v = Reflect.get(sTarget, sProp, sRecv);
+      return typeof v === "function" ? v.bind(sTarget) : v;
+    },
+  });
 }
 
 /**
@@ -258,37 +245,40 @@ function wrapSession(session: any, rls: RlsSessionContext, reuseOuterConnection:
  * `db.transaction()` still injects the same variables at the start of the callback transaction.
  */
 export function createRlsDb(
-    db: PgDatabase<any, any, any>,
-    rls: RlsSessionContext,
-): PgDatabase<any, any, any> {
-    const reuseOuterConnection = isDrizzleTransactionDb(db);
-    const baseSession = (db as unknown as { session: any }).session;
-    const wrappedSession = wrapSession(baseSession, rls, reuseOuterConnection);
+  db: PgAsyncDatabase<any, any, any, any>,
+  rls: RlsSessionContext,
+): PgAsyncDatabase<any, any, any, any> {
+  const reuseOuterConnection = isDrizzleTransactionDb(db);
+  const baseSession = (db as unknown as { session: any }).session;
+  const wrappedSession = wrapSession(baseSession, rls, reuseOuterConnection);
 
-    return new Proxy(db, {
-        get(target, prop, receiver) {
-            if (prop === "session") {
-                return wrappedSession;
-            }
-            if (prop === "_") {
-                const inner = target._;
-                return new Proxy(inner, {
-                    get(i, p, r) {
-                        if (p === "session") return wrappedSession;
-                        return Reflect.get(i, p, r);
-                    },
-                });
-            }
-            if (prop === "transaction") {
-                return async (callback: any, ...rest: any[]) => {
-                    return await target.transaction(async (tx: any) => {
-                        await injectRlsVarsOnTx(tx, rls);
-                        return await callback(tx);
-                    }, ...rest as any);
-                };
-            }
-            const value = Reflect.get(target, prop, receiver);
-            return typeof value === "function" ? value.bind(receiver) : value;
-        },
-    });
+  return new Proxy(db, {
+    get(target, prop, receiver) {
+      if (prop === "session") {
+        return wrappedSession;
+      }
+      if (prop === "_") {
+        const inner = target._;
+        return new Proxy(inner, {
+          get(i, p, r) {
+            if (p === "session") return wrappedSession;
+            return Reflect.get(i, p, r);
+          },
+        });
+      }
+      if (prop === "transaction") {
+        return async (callback: any, ...rest: any[]) => {
+          return await target.transaction(
+            async (tx: any) => {
+              await injectRlsVarsOnTx(tx, rls);
+              return await callback(tx);
+            },
+            ...(rest as any),
+          );
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(receiver) : value;
+    },
+  });
 }