@gencow/core 0.1.23 → 0.1.25

package/src/crud.ts

@@ -35,7 +35,26 @@
  * 📦 참조: saas-js/drizzle-crud 팩토리 패턴
  */
 
-import { eq, ne, gt, gte, lt, lte, desc, asc, like, ilike, inArray, notInArray, or, and, count as drizzleCount, getTableName, getTableColumns, type SQL } from "drizzle-orm";
+import {
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  desc,
+  asc,
+  like,
+  ilike,
+  inArray,
+  notInArray,
+  or,
+  and,
+  count as drizzleCount,
+  getTableName,
+  getTableColumns,
+  type SQL,
+} from "drizzle-orm";
 import type { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
 import { getTableConfig } from "drizzle-orm/pg-core";
 import { query, mutation } from "./reactive.js";
@@ -48,41 +67,45 @@ import { getOwnerRlsMeta, registerOwnerRls } from "./rls.js";
 const _ownerRlsTables: { tableName: string; columnName: string; readPublic: boolean }[] = [];
 
 /** 부트 로그에서 ownerRls 감지 테이블 목록을 반환 */
-export function getOwnerRlsTables(): readonly { tableName: string; columnName: string; readPublic: boolean }[] {
-    return _ownerRlsTables;
+export function getOwnerRlsTables(): readonly {
+  tableName: string;
+  columnName: string;
+  readPublic: boolean;
+}[] {
+  return _ownerRlsTables;
 }
 
 // ─── Types ──────────────────────────────────────────────
 
 type CrudOptions<T extends PgTable> = {
-    /** 검색 대상 필드 — list의 search 파라미터에 사용 */
-    searchFields?: (keyof T["_"]["columns"])[];
-    /** 소프트 삭제 컬럼 (e.g. deletedAt) */
-    softDelete?: { field: keyof T["_"]["columns"] };
-    /** 필터링 허용 필드 — allowedFilters에 없는 키는 무시 (보안) */
-    allowedFilters?: (keyof T["_"]["columns"])[];
-    /** 기본 페이지 크기 (default: 20) */
-    defaultLimit?: number;
-    /** 최대 페이지 크기 (default: 100) */
-    maxLimit?: number;
-    /** 라이프사이클 훅 */
-    hooks?: {
-        beforeCreate?: (data: any) => any | Promise<any>;
-        beforeUpdate?: (data: any) => any | Promise<any>;
-    };
-    /** true면 인증 없이 접근 가능 (기본: false — Secure by Default) */
-    public?: boolean;
-    /** true면 mutation 후 realtime push (기본: true) */
-    realtime?: boolean;
-    /** 키 접두사 오버라이드 (기본: 테이블명) */
-    prefix?: string;
-    /**
-     * 생성할 메서드 목록 (기본: 전체 5개)
-     * 지정하면 해당 메서드만 레지스트리에 등록되고 반환됨.
-     * api.ts codegen에도 지정된 메서드만 포함됨.
-     * @example crud(table, { methods: ['list', 'get', 'create'] })
-     */
-    methods?: ('list' | 'get' | 'create' | 'update' | 'remove')[];
+  /** 검색 대상 필드 — list의 search 파라미터에 사용 */
+  searchFields?: (keyof T["_"]["columns"])[];
+  /** 소프트 삭제 컬럼 (e.g. deletedAt) */
+  softDelete?: { field: keyof T["_"]["columns"] };
+  /** 필터링 허용 필드 — allowedFilters에 없는 키는 무시 (보안) */
+  allowedFilters?: (keyof T["_"]["columns"])[];
+  /** 기본 페이지 크기 (default: 20) */
+  defaultLimit?: number;
+  /** 최대 페이지 크기 (default: 100) */
+  maxLimit?: number;
+  /** 라이프사이클 훅 */
+  hooks?: {
+    beforeCreate?: (data: any) => any | Promise<any>;
+    beforeUpdate?: (data: any) => any | Promise<any>;
+  };
+  /** true면 인증 없이 접근 가능 (기본: false — Secure by Default) */
+  public?: boolean;
+  /** true면 mutation 후 realtime push (기본: true) */
+  realtime?: boolean;
+  /** 키 접두사 오버라이드 (기본: 테이블명) */
+  prefix?: string;
+  /**
+   * 생성할 메서드 목록 (기본: 전체 5개)
+   * 지정하면 해당 메서드만 레지스트리에 등록되고 반환됨.
+   * api.ts codegen에도 지정된 메서드만 포함됨.
+   * @example crud(table, { methods: ['list', 'get', 'create'] })
+   */
+  methods?: ("list" | "get" | "create" | "update" | "remove")[];
 };
 
 // ─── Helpers ────────────────────────────────────────────
@@ -93,22 +116,22 @@ type CrudOptions<T extends PgTable> = {
  * text/uuid/varchar → v.string()
  */
 function detectIdType(column: AnyPgColumn) {
-    const colType = (column as any).dataType;
-    if (colType === "string") return v.string();
-    return v.number();
+  const colType = (column as any).dataType;
+  if (colType === "string") return v.string();
+  return v.number();
 }
 
 // ─── ownerRls 감지 ──────────────────────────────────────
 
 interface OwnerMetaResolved {
-    /** userId 역할을 하는 Drizzle 컬럼 참조 (WHERE 조건에 사용) */
-    column: AnyPgColumn;
-    /** userId 컬럼의 DB 이름 (e.g. "user_id") */
-    columnName: string;
-    /** userId 컬럼의 JS 프로퍼티 이름 (e.g. "userId" — INSERT/UPDATE 데이터 키에 사용) */
-    propertyName: string;
-    /** true면 SELECT에 userId 필터 생략 (누구나 읽기 가능) */
-    readPublic: boolean;
+  /** userId 역할을 하는 Drizzle 컬럼 참조 (WHERE 조건에 사용) */
+  column: AnyPgColumn;
+  /** userId 컬럼의 DB 이름 (e.g. "user_id") */
+  columnName: string;
+  /** userId 컬럼의 JS 프로퍼티 이름 (e.g. "userId" — INSERT/UPDATE 데이터 키에 사용) */
+  propertyName: string;
+  /** true면 SELECT에 userId 필터 생략 (누구나 읽기 가능) */
+  readPublic: boolean;
 }
 
 /**
@@ -117,15 +140,15 @@ interface OwnerMetaResolved {
  * 매칭 실패 시 columnName을 그대로 반환 (best-effort).
  */
 function resolvePropertyName(table: PgTable, columnName: string): string {
-    try {
-        const columns = getTableColumns(table);
-        for (const [propName, col] of Object.entries(columns)) {
-            if ((col as any).name === columnName) return propName;
-        }
-    } catch {
-        // 테스트 환경에서 getTableColumns 실패 가능 — fallback
+  try {
+    const columns = getTableColumns(table);
+    for (const [propName, col] of Object.entries(columns)) {
+      if ((col as any).name === columnName) return propName;
     }
-    return columnName;
+  } catch {
+    // 테스트 환경에서 getTableColumns 실패 가능 — fallback
+  }
+  return columnName;
 }
 
 /**
@@ -139,50 +162,55 @@ function resolvePropertyName(table: PgTable, columnName: string): string {
  * ownerRls가 적용된 것으로 간주.
  */
 function detectOwnerMeta(table: PgTable): OwnerMetaResolved | null {
-    const anyTable = table as any;
-
-    // 1. WeakMap 레지스트리에서 조회 (가장 정확)
-    const meta = getOwnerRlsMeta(table);
-    if (meta) {
-        // propertyName 역매핑: DB명 "user_id" → JS명 "userId"
-        const propName = resolvePropertyName(table, meta.columnName);
-        const col = anyTable[propName] as AnyPgColumn | undefined;
-        if (col) {
-            return { column: col, columnName: meta.columnName, propertyName: propName, readPublic: meta.readPublic };
-        }
+  const anyTable = table as any;
+
+  // 1. WeakMap 레지스트리에서 조회 (가장 정확)
+  const meta = getOwnerRlsMeta(table);
+  if (meta) {
+    // propertyName 역매핑: DB명 "user_id" → JS명 "userId"
+    const propName = resolvePropertyName(table, meta.columnName);
+    const col = anyTable[propName] as AnyPgColumn | undefined;
+    if (col) {
+      return {
+        column: col,
+        columnName: meta.columnName,
+        propertyName: propName,
+        readPublic: meta.readPublic,
+      };
     }
-
-    // 2. getTableConfig().policies로 pgPolicy 존재 감지 + convention 탐색
-    try {
-        const config = getTableConfig(table);
-        if (config.policies && config.policies.length > 0) {
-            // convention: userId 또는 user_id 컬럼 탐색 (JS 프로퍼티명)
-            const propName = anyTable["userId"] ? "userId" : anyTable["user_id"] ? "user_id" : null;
-            if (propName) {
-                const userIdCol = anyTable[propName] as AnyPgColumn;
-                const colName = (userIdCol as any).name || "user_id";
-
-                // 테이블에 메타 등록 (이후 호출에서 WeakMap으로 빠르게 조회)
-                registerOwnerRls(table, { columnName: colName, readPublic: false });
-
-                return { column: userIdCol, columnName: colName, propertyName: propName, readPublic: false };
-            }
-
-            // S2 방어: pgPolicy가 존재하지만 convention 컬럼(userId/user_id)이 없는 경우
-            // ownerRls()를 호출했으나 비표준 컬럼명(e.g. ownerId, authorId)을 사용한 것으로 의심
-            // → silent 무시 방지: 보안 경고 출력
-            const tblName = getTableName(table);
-            console.warn(
-                `[crud] ⚠️ Table "${tblName}" has ${config.policies.length} pgPolicy but no userId/user_id column found. ` +
-                `ownerRls auto-isolation will NOT be applied. ` +
-                `If you used ownerRls(), ensure the column is named 'userId' (JS) / 'user_id' (DB).`
-            );
-        }
-    } catch {
-        // getTableConfig 실패 시 무시 (테스트 환경 등)
+  }
+
+  // 2. getTableConfig().policies로 pgPolicy 존재 감지 + convention 탐색
+  try {
+    const config = getTableConfig(table);
+    if (config.policies && config.policies.length > 0) {
+      // convention: userId 또는 user_id 컬럼 탐색 (JS 프로퍼티명)
+      const propName = anyTable["userId"] ? "userId" : anyTable["user_id"] ? "user_id" : null;
+      if (propName) {
+        const userIdCol = anyTable[propName] as AnyPgColumn;
+        const colName = (userIdCol as any).name || "user_id";
+
+        // 테이블에 메타 등록 (이후 호출에서 WeakMap으로 빠르게 조회)
+        registerOwnerRls(table, { columnName: colName, readPublic: false });
+
+        return { column: userIdCol, columnName: colName, propertyName: propName, readPublic: false };
+      }
+
+      // S2 방어: pgPolicy가 존재하지만 convention 컬럼(userId/user_id)이 없는 경우
+      // ownerRls()를 호출했으나 비표준 컬럼명(e.g. ownerId, authorId)을 사용한 것으로 의심
+      // → silent 무시 방지: 보안 경고 출력
+      const tblName = getTableName(table);
+      console.warn(
+        `[crud] ⚠️ Table "${tblName}" has ${config.policies.length} pgPolicy but no userId/user_id column found. ` +
+          `ownerRls auto-isolation will NOT be applied. ` +
+          `If you used ownerRls(), ensure the column is named 'userId' (JS) / 'user_id' (DB).`,
+      );
     }
+  } catch {
+    // getTableConfig 실패 시 무시 (테스트 환경 등)
+  }
 
-    return null;
+  return null;
 }
 
 // ─── v3 Filter Engine — 재귀적 동적 필터링 ──────────────
@@ -191,11 +219,11 @@ function detectOwnerMeta(table: PgTable): OwnerMetaResolved | null {
 const MAX_FILTER_DEPTH = 5;
 
 /** 지원 연산자 목록 */
-const FILTER_OPS = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'ilike'] as const;
-type FilterOp = typeof FILTER_OPS[number];
+const FILTER_OPS = ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "like", "ilike"] as const;
+type FilterOp = (typeof FILTER_OPS)[number];
 
 function isValidFilterOp(op: string): op is FilterOp {
-    return (FILTER_OPS as readonly string[]).includes(op);
+  return (FILTER_OPS as readonly string[]).includes(op);
 }
 
 /**
@@ -203,27 +231,34 @@ function isValidFilterOp(op: string): op is FilterOp {
  * 지원하지 않는 op이거나 값 타입이 맞지 않으면 undefined 반환 (묵살).
  */
 export function applyFilterOp(col: AnyPgColumn, op: FilterOp, value: unknown): SQL | undefined {
-    switch (op) {
-        case 'eq':    return eq(col, value);
-        case 'ne':    return ne(col, value);
-        case 'gt':    return gt(col, value as any);
-        case 'gte':   return gte(col, value as any);
-        case 'lt':    return lt(col, value as any);
-        case 'lte':   return lte(col, value as any);
-        case 'in':
-            if (!Array.isArray(value) || value.length === 0) return undefined;
-            return inArray(col, value);
-        case 'nin':
-            if (!Array.isArray(value) || value.length === 0) return undefined;
-            return notInArray(col, value);
-        case 'like':
-            if (typeof value !== 'string') return undefined;
-            return like(col, value);
-        case 'ilike':
-            if (typeof value !== 'string') return undefined;
-            return ilike(col, value);
-        default:      return undefined;
-    }
+  switch (op) {
+    case "eq":
+      return eq(col, value);
+    case "ne":
+      return ne(col, value);
+    case "gt":
+      return gt(col, value as any);
+    case "gte":
+      return gte(col, value as any);
+    case "lt":
+      return lt(col, value as any);
+    case "lte":
+      return lte(col, value as any);
+    case "in":
+      if (!Array.isArray(value) || value.length === 0) return undefined;
+      return inArray(col, value);
+    case "nin":
+      if (!Array.isArray(value) || value.length === 0) return undefined;
+      return notInArray(col, value);
+    case "like":
+      if (typeof value !== "string") return undefined;
+      return like(col, value);
+    case "ilike":
+      if (typeof value !== "string") return undefined;
+      return ilike(col, value);
+    default:
+      return undefined;
+  }
 }
 
 /**
@@ -249,62 +284,66 @@ export function applyFilterOp(col: AnyPgColumn, op: FilterOp, value: unknown): S
  * ```
  */
 export function parseFilterNode(
-    node: Record<string, unknown>,
-    table: any,
-    allowedFields?: readonly string[],
-    depth: number = 0,
+  node: Record<string, unknown>,
+  table: any,
+  allowedFields?: readonly string[],
+  depth: number = 0,
 ): SQL | undefined {
-    // DoS 방어: 재귀 깊이 제한 초과 시 조건 묵살
-    if (depth > MAX_FILTER_DEPTH) return undefined;
+  // DoS 방어: 재귀 깊이 제한 초과 시 조건 묵살
+  if (depth > MAX_FILTER_DEPTH) return undefined;
+
+  const conditions: SQL[] = [];
+
+  for (const [key, val] of Object.entries(node)) {
+    // ── OR 논리 그룹 ──
+    if (key === "OR") {
+      if (!Array.isArray(val)) continue; // 잘못된 타입 → 묵살
+      const orConds = val
+        .filter(
+          (child): child is Record<string, unknown> =>
+            child != null && typeof child === "object" && !Array.isArray(child),
+        )
+        .map((child) => parseFilterNode(child, table, allowedFields, depth + 1))
+        .filter((c): c is SQL => c !== undefined);
+      if (orConds.length > 0) conditions.push(or(...orConds)!);
+      continue;
+    }
 
-    const conditions: SQL[] = [];
+    // ── AND 논리 그룹 ──
+    if (key === "AND") {
+      if (!Array.isArray(val)) continue;
+      const andConds = val
+        .filter(
+          (child): child is Record<string, unknown> =>
+            child != null && typeof child === "object" && !Array.isArray(child),
+        )
+        .map((child) => parseFilterNode(child, table, allowedFields, depth + 1))
+        .filter((c): c is SQL => c !== undefined);
+      if (andConds.length > 0) conditions.push(and(...andConds)!);
+      continue;
+    }
+
+    // ── 컬럼 필터 ──
+    // allowedFields 화이트리스트 검증 (재귀적으로 OR/AND 내부에도 적용됨)
+    if (allowedFields && !allowedFields.includes(key)) continue;
 
-    for (const [key, val] of Object.entries(node)) {
-        // ── OR 논리 그룹 ──
-        if (key === 'OR') {
-            if (!Array.isArray(val)) continue; // 잘못된 타입 → 묵살
-            const orConds = val
-                .filter((child): child is Record<string, unknown> =>
-                    child != null && typeof child === 'object' && !Array.isArray(child))
-                .map((child) => parseFilterNode(child, table, allowedFields, depth + 1))
-                .filter((c): c is SQL => c !== undefined);
-            if (orConds.length > 0) conditions.push(or(...orConds)!);
-            continue;
-        }
-
-        // ── AND 논리 그룹 ──
-        if (key === 'AND') {
-            if (!Array.isArray(val)) continue;
-            const andConds = val
-                .filter((child): child is Record<string, unknown> =>
-                    child != null && typeof child === 'object' && !Array.isArray(child))
-                .map((child) => parseFilterNode(child, table, allowedFields, depth + 1))
-                .filter((c): c is SQL => c !== undefined);
-            if (andConds.length > 0) conditions.push(and(...andConds)!);
-            continue;
-        }
-
-        // ── 컬럼 필터 ──
-        // allowedFields 화이트리스트 검증 (재귀적으로 OR/AND 내부에도 적용됨)
-        if (allowedFields && !allowedFields.includes(key)) continue;
-
-        const col = table[key] as AnyPgColumn | undefined;
-        if (!col) continue;
-
-        // 명시적 연산자: { op: 'gte', value: 10 }
-        if (val != null && typeof val === 'object' && !Array.isArray(val) && 'op' in val) {
-            const { op, value } = val as { op: string; value: unknown };
-            if (!isValidFilterOp(op)) continue; // 미지원 op → 묵살
-            const cond = applyFilterOp(col, op, value);
-            if (cond) conditions.push(cond);
-            continue;
-        }
-
-        // 암묵적 eq (v2 하위호환): { status: 'active' } → eq(status, 'active')
-        conditions.push(eq(col, val));
+    const col = table[key] as AnyPgColumn | undefined;
+    if (!col) continue;
+
+    // 명시적 연산자: { op: 'gte', value: 10 }
+    if (val != null && typeof val === "object" && !Array.isArray(val) && "op" in val) {
+      const { op, value } = val as { op: string; value: unknown };
+      if (!isValidFilterOp(op)) continue; // 미지원 op → 묵살
+      const cond = applyFilterOp(col, op, value);
+      if (cond) conditions.push(cond);
+      continue;
     }
 
-    return conditions.length > 0 ? and(...conditions) : undefined;
+    // 암묵적 eq (v2 하위호환): { status: 'active' } → eq(status, 'active')
+    conditions.push(eq(col, val));
+  }
+
+  return conditions.length > 0 ? and(...conditions) : undefined;
 }
 
 // ─── crud — Zero-Boilerplate API Factory ──────────
@@ -322,363 +361,368 @@ export function parseFilterNode(
  * ```
  */
 export function crud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
-    const anyTable = table as any;
-    const tableName: string = getTableName(table); // Drizzle 공식 API
-    const prefix = options?.prefix || tableName;
-    const isPublic = options?.public ?? false;
-    const useRealtime = options?.realtime ?? true;
-    const defaultLimit = options?.defaultLimit ?? 20;
-    const maxLimit = options?.maxLimit ?? 100;
-    const pk = anyTable["id"] as AnyPgColumn;
-
-    if (!pk) {
-        throw new Error(`[crud] Table "${tableName}" must have an 'id' column.`);
-    }
-
-    // id 타입 자동 감지 (serial → v.number(), text/uuid → v.string())
-    const idValidator = detectIdType(pk);
-
-    // createdAt 컬럼 (정렬용, 없으면 id 사용)
-    const createdAtCol = anyTable["createdAt"] as AnyPgColumn | undefined;
-    const defaultOrderCol = createdAtCol || pk;
-
-    // userId 컬럼 (자동 주입용 — ownerRls 미적용 시 기존 동작)
-    const userIdCol = anyTable["userId"] as AnyPgColumn | undefined;
-
-    // ── ownerRls 감지: 2-Layer 방어의 Layer 1 ──
-    // ownerRls() 메타데이터가 감지되면 모든 CRUD에 userId 필터 자동 주입
-    const ownerMeta = detectOwnerMeta(table);
+  const anyTable = table as any;
+  const tableName: string = getTableName(table); // Drizzle 공식 API
+  const prefix = options?.prefix || tableName;
+  const isPublic = options?.public ?? false;
+  const useRealtime = options?.realtime ?? true;
+  const defaultLimit = options?.defaultLimit ?? 20;
+  const maxLimit = options?.maxLimit ?? 100;
+  const pk = anyTable["id"] as AnyPgColumn;
+
+  if (!pk) {
+    throw new Error(`[crud] Table "${tableName}" must have an 'id' column.`);
+  }
+
+  // id 타입 자동 감지 (serial → v.number(), text/uuid → v.string())
+  const idValidator = detectIdType(pk);
+
+  // createdAt 컬럼 (정렬용, 없으면 id 사용)
+  const createdAtCol = anyTable["createdAt"] as AnyPgColumn | undefined;
+  const defaultOrderCol = createdAtCol || pk;
+
+  // userId 컬럼 (자동 주입용 — ownerRls 미적용 시 기존 동작)
+  const userIdCol = anyTable["userId"] as AnyPgColumn | undefined;
+
+  // ── ownerRls 감지: 2-Layer 방어의 Layer 1 ──
+  // ownerRls() 메타데이터가 감지되면 모든 CRUD에 userId 필터 자동 주입
+  const ownerMeta = detectOwnerMeta(table);
+
+  // 부트 로그용 레지스트리 등록 (S1: 중복 방지 — hot-reload/methods 분할 대응)
+  if (ownerMeta && !_ownerRlsTables.some((t) => t.tableName === tableName)) {
+    _ownerRlsTables.push({
+      tableName,
+      columnName: ownerMeta.columnName,
+      readPublic: ownerMeta.readPublic,
+    });
+  }
+
+  // B1: public + ownerRls 조합 방어
+  // ownerRls가 감지된 테이블에서 public: true + readPublic: false 조합은
+  // 보안 의도와 모순 → 경고 출력 + CUD는 ownerRls 보호 유지
+  if (ownerMeta && isPublic && !ownerMeta.readPublic) {
+    console.warn(
+      `[crud] ⚠️ Table "${tableName}": ownerRls detected but public=true. ` +
+        `CUD operations will still enforce ownerRls (auth required). ` +
+        `Consider removing { public: true } or using ownerRls(col, { read: "public" }).`,
+    );
+  }
+
+  // ── 내부 헬퍼: WHERE 조건 빌드 (list + count + realtime 공유) ──
+  function buildWhereConditions(args: any): SQL | undefined {
+    const conditions: SQL[] = [];
 
-    // 부트 로그용 레지스트리 등록 (S1: 중복 방지 — hot-reload/methods 분할 대응)
-    if (ownerMeta && !_ownerRlsTables.some(t => t.tableName === tableName)) {
-        _ownerRlsTables.push({
-            tableName,
-            columnName: ownerMeta.columnName,
-            readPublic: ownerMeta.readPublic,
-        });
+    // Soft delete
+    if (options?.softDelete) {
+      const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
+      conditions.push(eq(sdField, null as any));
     }
 
-    // B1: public + ownerRls 조합 방어
-    // ownerRls가 감지된 테이블에서 public: true + readPublic: false 조합은
-    // 보안 의도와 모순 → 경고 출력 + CUD는 ownerRls 보호 유지
-    if (ownerMeta && isPublic && !ownerMeta.readPublic) {
-        console.warn(
-            `[crud] ⚠️ Table "${tableName}": ownerRls detected but public=true. ` +
-            `CUD operations will still enforce ownerRls (auth required). ` +
-            `Consider removing { public: true } or using ownerRls(col, { read: "public" }).`
-        );
+    // Search
+    if (args?.search && options?.searchFields?.length) {
+      const searchConds = options.searchFields.map((f) =>
+        ilike(anyTable[f as string] as AnyPgColumn, `%${args.search}%`),
+      );
+      conditions.push(or(...searchConds)!);
     }
 
-    // ── 내부 헬퍼: WHERE 조건 빌드 (list + count + realtime 공유) ──
-    function buildWhereConditions(args: any): SQL | undefined {
-        const conditions: SQL[] = [];
-
-        // Soft delete
-        if (options?.softDelete) {
-            const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
-            conditions.push(eq(sdField, null as any));
-        }
-
-        // Search
-        if (args?.search && options?.searchFields?.length) {
-            const searchConds = options.searchFields.map(
-                (f) => ilike(anyTable[f as string] as AnyPgColumn, `%${args.search}%`)
-            );
-            conditions.push(or(...searchConds)!);
-        }
-
-        // Dynamic filters — v3 재귀적 파싱 엔진 (OR/AND 중첩, 연산자 매핑)
-        // allowedFilters 설정 시: 화이트리스트 필드만 허용 (재귀 검증)
-        // allowedFilters 미설정 시: 필터 전체 무시 (Secure by Default — v2 호환)
-        if (args?.filters && typeof args.filters === 'object' && options?.allowedFilters?.length) {
-            const allowedFields = options.allowedFilters as unknown as string[];
-            const filterCondition = parseFilterNode(
-                args.filters as Record<string, unknown>,
-                anyTable,
-                allowedFields,
-            );
-            if (filterCondition) conditions.push(filterCondition);
-        }
-
-        return conditions.length > 0 ? and(...conditions) : undefined;
+    // Dynamic filters — v3 재귀적 파싱 엔진 (OR/AND 중첩, 연산자 매핑)
+    // allowedFilters 설정 시: 화이트리스트 필드만 허용 (재귀 검증)
+    // allowedFilters 미설정 시: 필터 전체 무시 (Secure by Default — v2 호환)
+    if (args?.filters && typeof args.filters === "object" && options?.allowedFilters?.length) {
+      const allowedFields = options.allowedFilters as unknown as string[];
+      const filterCondition = parseFilterNode(
+        args.filters as Record<string, unknown>,
+        anyTable,
+        allowedFields,
+      );
+      if (filterCondition) conditions.push(filterCondition);
     }
 
-    /** Uses `db.transaction` when present (e.g. createRlsDb); else runs `fn(db)` for test mocks without `.transaction`. */
-    async function inRlsOrPlainTx<T>(db: any, fn: (tx: any) => Promise<T>): Promise<T> {
-        if (typeof db?.transaction === "function") {
-            return await db.transaction(fn);
-        }
-        return await fn(db);
-    }
+    return conditions.length > 0 ? and(...conditions) : undefined;
+  }
 
-    // ── 내부 헬퍼: list+count 데이터 가져오기 (realtime push용 재사용) ──
-    // Runs inside db.transaction so createRlsDb() RLS session vars apply for RLS.
-    // ⚠️ limit/offset 없이 전체 SELECT — 대량 데이터 시 성능 저하 주의
-    // TODO(P2): realtime emit 시 invalidation 메시지만 전송하고 클라이언트가 re-fetch하는 패턴 검토
-    async function fetchListWithTotal(db: any, whereClause?: SQL, userId?: string) {
-        // ownerRls 적용 시 realtime emit에도 userId 필터 추가
-        // → 다른 사용자에게 타인 데이터가 push되지 않도록
-        let effectiveWhere = whereClause;
-        if (ownerMeta && userId && !ownerMeta.readPublic) {
-            const ownerFilter = eq(ownerMeta.column, userId);
-            effectiveWhere = effectiveWhere ? and(effectiveWhere, ownerFilter) : ownerFilter;
-        }
-        return await inRlsOrPlainTx(db, async (tx: any) => {
-            const data = await tx.select().from(anyTable).where(effectiveWhere).orderBy(desc(defaultOrderCol));
-            const countResult = await tx.select({ count: drizzleCount() }).from(anyTable).where(effectiveWhere);
-            return { data, total: Number(countResult[0]?.count ?? 0) };
-        });
+  /** Uses `db.transaction` when present (e.g. createRlsDb); else runs `fn(db)` for test mocks without `.transaction`. */
+  async function inRlsOrPlainTx<T>(db: any, fn: (tx: any) => Promise<T>): Promise<T> {
+    if (typeof db?.transaction === "function") {
+      return await db.transaction(fn);
     }
+    return await fn(db);
+  }
+
+  // ── 내부 헬퍼: list+count 데이터 가져오기 (realtime push용 재사용) ──
+  // Runs inside db.transaction so createRlsDb() RLS session vars apply for RLS.
+  // ⚠️ limit/offset 없이 전체 SELECT — 대량 데이터 시 성능 저하 주의
+  // TODO(P2): realtime emit 시 invalidation 메시지만 전송하고 클라이언트가 re-fetch하는 패턴 검토
+  async function fetchListWithTotal(db: any, whereClause?: SQL, userId?: string) {
+    // ownerRls 적용 시 realtime emit에도 userId 필터 추가
+    // → 다른 사용자에게 타인 데이터가 push되지 않도록
+    let effectiveWhere = whereClause;
+    if (ownerMeta && userId && !ownerMeta.readPublic) {
+      const ownerFilter = eq(ownerMeta.column, userId);
+      effectiveWhere = effectiveWhere ? and(effectiveWhere, ownerFilter) : ownerFilter;
+    }
+    return await inRlsOrPlainTx(db, async (tx: any) => {
+      const data = await tx.select().from(anyTable).where(effectiveWhere).orderBy(desc(defaultOrderCol));
+      const countResult = await tx.select({ count: drizzleCount() }).from(anyTable).where(effectiveWhere);
+      return { data, total: Number(countResult[0]?.count ?? 0) };
+    });
+  }
 
-    // ── methods 필터링: 지정된 메서드만 레지스트리 등록 ──
-    // methods 옵션 미지정 시 전체 5개 등록 (하위호환)
-    const enabledMethods = new Set(options?.methods ?? ['list', 'get', 'create', 'update', 'remove']);
+  // ── methods 필터링: 지정된 메서드만 레지스트리 등록 ──
+  // methods 옵션 미지정 시 전체 5개 등록 (하위호환)
+  const enabledMethods = new Set(options?.methods ?? ["list", "get", "create", "update", "remove"]);
 
-    // ── list ──────────────────────────────────────
+  // ── list ──────────────────────────────────────
 
-    const listDef = !enabledMethods.has('list') ? undefined : query(`${prefix}.list`, {
+  const listDef = !enabledMethods.has("list")
+    ? undefined
+    : query(`${prefix}.list`, {
         public: isPublic,
         args: {
-            page: v.optional(v.number()),
-            limit: v.optional(v.number()),
-            search: v.optional(v.string()),
-            orderBy: v.optional(v.string()),
-            orderDir: v.optional(v.string()),
-            filters: v.optional(v.any()),
+          page: v.optional(v.number()),
+          limit: v.optional(v.number()),
+          search: v.optional(v.string()),
+          orderBy: v.optional(v.string()),
+          orderDir: v.optional(v.string()),
+          filters: v.optional(v.any()),
         },
         handler: async (ctx: any, args: any) => {
-            // S2: requireAuth 통합 — ownerRls(readPublic=false)이면 인증 필수
-            const needsAuth = !isPublic || (ownerMeta && !ownerMeta.readPublic);
-            const user = needsAuth ? ctx.auth.requireAuth() : null;
-
-            const page = Math.max(1, args?.page || 1);
-            const limit = Math.min(Math.max(1, args?.limit || defaultLimit), maxLimit);
-            const offset = (page - 1) * limit;
-
-            let whereClause = buildWhereConditions(args);
-
-            // ── ownerRls Layer 1: list에 userId 필터 주입 ──
-            if (ownerMeta && !ownerMeta.readPublic && user) {
-                const ownerFilter = eq(ownerMeta.column, user.id);
-                whereClause = whereClause ? and(whereClause, ownerFilter) : ownerFilter;
-            }
-
-            // Order
-            let orderByClause;
-            if (args?.orderBy && anyTable[args.orderBy]) {
-                const col = anyTable[args.orderBy] as AnyPgColumn;
-                orderByClause = args.orderDir === "asc" ? asc(col) : desc(col);
-            } else {
-                orderByClause = desc(defaultOrderCol);
-            }
-
-            // One transaction: SET LOCAL user id (createRlsDb) + list + count for RLS.
-            return await inRlsOrPlainTx(ctx.db, async (tx: any) => {
-                const results = await tx.select()
-                    .from(anyTable)
-                    .where(whereClause)
-                    .orderBy(orderByClause)
-                    .limit(limit)
-                    .offset(offset);
-                const countResult = await tx.select({ count: drizzleCount() })
-                    .from(anyTable)
-                    .where(whereClause);
-
-                return {
-                    data: results,
-                    total: Number(countResult[0]?.count ?? 0),
-                };
-            });
-        }
-    });
+          // S2: requireAuth 통합 — ownerRls(readPublic=false)이면 인증 필수
+          const needsAuth = !isPublic || (ownerMeta && !ownerMeta.readPublic);
+          const user = needsAuth ? ctx.auth.requireAuth() : null;
+
+          const page = Math.max(1, args?.page || 1);
+          const limit = Math.min(Math.max(1, args?.limit || defaultLimit), maxLimit);
+          const offset = (page - 1) * limit;
+
+          let whereClause = buildWhereConditions(args);
+
+          // ── ownerRls Layer 1: list에 userId 필터 주입 ──
+          if (ownerMeta && !ownerMeta.readPublic && user) {
+            const ownerFilter = eq(ownerMeta.column, user.id);
+            whereClause = whereClause ? and(whereClause, ownerFilter) : ownerFilter;
+          }
+
+          // Order
+          let orderByClause;
+          if (args?.orderBy && anyTable[args.orderBy]) {
+            const col = anyTable[args.orderBy] as AnyPgColumn;
+            orderByClause = args.orderDir === "asc" ? asc(col) : desc(col);
+          } else {
+            orderByClause = desc(defaultOrderCol);
+          }
+
+          // One transaction: SET LOCAL user id (createRlsDb) + list + count for RLS.
+          return await inRlsOrPlainTx(ctx.db, async (tx: any) => {
+            const results = await tx
+              .select()
+              .from(anyTable)
+              .where(whereClause)
+              .orderBy(orderByClause)
+              .limit(limit)
+              .offset(offset);
+            const countResult = await tx.select({ count: drizzleCount() }).from(anyTable).where(whereClause);
+
+            return {
+              data: results,
+              total: Number(countResult[0]?.count ?? 0),
+            };
+          });
+        },
+      });
 
-    // ── get ───────────────────────────────────────
+  // ── get ───────────────────────────────────────
 
-    const getDef = !enabledMethods.has('get') ? undefined : query(`${prefix}.get`, {
+  const getDef = !enabledMethods.has("get")
+    ? undefined
+    : query(`${prefix}.get`, {
         public: isPublic,
         args: { id: idValidator },
         handler: async (ctx: any, args: any) => {
-            // S2: requireAuth 통합
-            const needsAuth = !isPublic || (ownerMeta && !ownerMeta.readPublic);
-            const user = needsAuth ? ctx.auth.requireAuth() : null;
+          // S2: requireAuth 통합
+          const needsAuth = !isPublic || (ownerMeta && !ownerMeta.readPublic);
+          const user = needsAuth ? ctx.auth.requireAuth() : null;
 
-            let whereCond: SQL = eq(pk, args.id);
+          let whereCond: SQL = eq(pk, args.id);
 
-            // ── ownerRls Layer 1: get에 userId 필터 주입 ──
-            if (ownerMeta && !ownerMeta.readPublic && user) {
-                whereCond = and(whereCond, eq(ownerMeta.column, user.id))!;
-            }
+          // ── ownerRls Layer 1: get에 userId 필터 주입 ──
+          if (ownerMeta && !ownerMeta.readPublic && user) {
+            whereCond = and(whereCond, eq(ownerMeta.column, user.id))!;
+          }
 
-            if (options?.softDelete) {
-                const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
-                whereCond = and(whereCond, eq(sdField, null as any))!;
-            }
+          if (options?.softDelete) {
+            const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
+            whereCond = and(whereCond, eq(sdField, null as any))!;
+          }
 
-            return await inRlsOrPlainTx(ctx.db, async (tx: any) => {
-                const [result] = await tx.select().from(anyTable).where(whereCond).limit(1);
-                return result ?? null;
-            });
-        }
-    });
+          return await inRlsOrPlainTx(ctx.db, async (tx: any) => {
+            const [result] = await tx.select().from(anyTable).where(whereCond).limit(1);
+            return result ?? null;
+          });
+        },
+      });
 
-    // ── create ────────────────────────────────────
+  // ── create ────────────────────────────────────
 
-    const createDef = !enabledMethods.has('create') ? undefined : mutation(`${prefix}.create`, {
+  const createDef = !enabledMethods.has("create")
+    ? undefined
+    : mutation(`${prefix}.create`, {
         public: isPublic,
         handler: async (ctx: any, args: any) => {
-            // ownerRls 테이블은 항상 인증 필수 (보안 우선)
-            const user = (ownerMeta || !isPublic) ? ctx.auth.requireAuth() : null;
-
-            let insertData = { ...args };
-
-            // ── ownerRls Layer 1: create 시 userId 강제 주입 ──
-            // 명시적으로 타인 userId를 보낸 경우는 즉시 차단 (fail-closed).
-            if (ownerMeta && user) {
-                const requestedOwner =
-                    insertData[ownerMeta.propertyName] ??
-                    insertData[ownerMeta.columnName] ??
-                    insertData.userId;
-                if (requestedOwner != null && requestedOwner !== user.id) {
-                    throw new Error("Forbidden: cannot create resource for another user");
-                }
-            }
-
-            // S1 수정: propertyName(JS명)을 키로 사용 — Drizzle insert 호환
-            // 사용자 입력을 덮어씀 (보안: 타인 ID로 데이터 생성 방지)
-            if (ownerMeta && user) {
-                insertData[ownerMeta.propertyName] = user.id;
-            } else if (userIdCol && user && !insertData.userId) {
-                // ownerRls 미적용 테이블의 기존 자동 주입 동작 유지
-                insertData.userId = user.id;
-            }
-
-            // beforeCreate 훅
-            if (options?.hooks?.beforeCreate) {
-                insertData = await options.hooks.beforeCreate(insertData);
-            }
-
-            const [result] = await inRlsOrPlainTx(ctx.db, async (tx: any) =>
-                tx.insert(anyTable).values(insertData).returning()
-            );
-
-            // Realtime push — { data, total } 형태로 emit
-            // ownerRls 시 해당 사용자 데이터만 push (타 사용자에게 누출 방지)
-            // S5: requireAuth로 확실한 userId 획득 (getUserIdentity null 방지)
-            if (useRealtime && enabledMethods.has('list')) {
-                const currentUserId = user?.id;
-                const listResult = await fetchListWithTotal(ctx.db, undefined, currentUserId);
-                ctx.realtime.emit(`${prefix}.list`, listResult);
+          // ownerRls 테이블은 항상 인증 필수 (보안 우선)
+          const user = ownerMeta || !isPublic ? ctx.auth.requireAuth() : null;
+
+          let insertData = { ...args };
+
+          // ── ownerRls Layer 1: create 시 userId 강제 주입 ──
+          // 명시적으로 타인 userId를 보낸 경우는 즉시 차단 (fail-closed).
+          if (ownerMeta && user) {
+            const requestedOwner =
+              insertData[ownerMeta.propertyName] ?? insertData[ownerMeta.columnName] ?? insertData.userId;
+            if (requestedOwner != null && requestedOwner !== user.id) {
+              throw new Error("Forbidden: cannot create resource for another user");
             }
+          }
+
+          // S1 수정: propertyName(JS명)을 키로 사용 — Drizzle insert 호환
+          // 사용자 입력을 덮어씀 (보안: 타인 ID로 데이터 생성 방지)
+          if (ownerMeta && user) {
+            insertData[ownerMeta.propertyName] = user.id;
+          } else if (userIdCol && user && !insertData.userId) {
+            // ownerRls 미적용 테이블의 기존 자동 주입 동작 유지
+            insertData.userId = user.id;
+          }
+
+          // beforeCreate 훅
+          if (options?.hooks?.beforeCreate) {
+            insertData = await options.hooks.beforeCreate(insertData);
+          }
+
+          const [result] = await inRlsOrPlainTx(ctx.db, async (tx: any) =>
+            tx.insert(anyTable).values(insertData).returning(),
+          );
+
+          // Realtime push — { data, total } 형태로 emit
+          // ownerRls 시 해당 사용자 데이터만 push (타 사용자에게 누출 방지)
+          // S5: requireAuth로 확실한 userId 획득 (getUserIdentity null 방지)
+          if (useRealtime && enabledMethods.has("list")) {
+            const currentUserId = user?.id;
+            const listResult = await fetchListWithTotal(ctx.db, undefined, currentUserId);
+            ctx.realtime.emit(`${prefix}.list`, listResult);
+          }
+
+          return result;
+        },
+      });
 
-            return result;
-        }
-    });
-
-    // ── update ────────────────────────────────────
+  // ── update ────────────────────────────────────
 
-    const updateDef = !enabledMethods.has('update') ? undefined : mutation(`${prefix}.update`, {
+  const updateDef = !enabledMethods.has("update")
+    ? undefined
+    : mutation(`${prefix}.update`, {
         public: isPublic,
         handler: async (ctx: any, args: any) => {
-            // ownerRls 테이블은 항상 인증 필수
-            const user = (ownerMeta || !isPublic) ? ctx.auth.requireAuth() : null;
-
-            const { id, ...updates } = args;
-
-            let updateData = { ...updates };
-
-            // ── ownerRls Layer 1: update 시 userId 변경 차단 + 소유자 검증 ──
-            let updateWhere: SQL = eq(pk, id);
-            if (ownerMeta && user) {
-                // WHERE id = ? AND user_id = ? (타인 데이터 수정 불가)
-                updateWhere = and(eq(pk, id), eq(ownerMeta.column, user.id))!;
-                // S1 수정: propertyName(JS명)으로 userId 변경 시도 차단
-                delete updateData[ownerMeta.propertyName];
-                // DB명도 방어적으로 삭제 (만약 클라이언트가 DB명으로 보낸 경우)
-                if (ownerMeta.propertyName !== ownerMeta.columnName) {
-                    delete updateData[ownerMeta.columnName];
-                }
-            }
-
-            // updatedAt 자동 갱신
-            if (anyTable["updatedAt"]) {
-                updateData.updatedAt = new Date();
+          // ownerRls 테이블은 항상 인증 필수
+          const user = ownerMeta || !isPublic ? ctx.auth.requireAuth() : null;
+
+          const { id, ...updates } = args;
+
+          let updateData = { ...updates };
+
+          // ── ownerRls Layer 1: update 시 userId 변경 차단 + 소유자 검증 ──
+          let updateWhere: SQL = eq(pk, id);
+          if (ownerMeta && user) {
+            // WHERE id = ? AND user_id = ? (타인 데이터 수정 불가)
+            updateWhere = and(eq(pk, id), eq(ownerMeta.column, user.id))!;
+            // S1 수정: propertyName(JS명)으로 userId 변경 시도 차단
+            delete updateData[ownerMeta.propertyName];
+            // DB명도 방어적으로 삭제 (만약 클라이언트가 DB명으로 보낸 경우)
+            if (ownerMeta.propertyName !== ownerMeta.columnName) {
+              delete updateData[ownerMeta.columnName];
             }
-
-            // beforeUpdate 훅
-            if (options?.hooks?.beforeUpdate) {
-                updateData = await options.hooks.beforeUpdate(updateData);
+          }
+
+          // updatedAt 자동 갱신
+          if (anyTable["updatedAt"]) {
+            updateData.updatedAt = new Date();
+          }
+
+          // beforeUpdate 훅
+          if (options?.hooks?.beforeUpdate) {
+            updateData = await options.hooks.beforeUpdate(updateData);
+          }
+
+          const [result] = await inRlsOrPlainTx(ctx.db, async (tx: any) =>
+            tx.update(anyTable).set(updateData).where(updateWhere).returning(),
+          );
+
+          // Realtime push (list + get 양쪽) — { data, total } 형태
+          // S5: ownerRls 시 user.id 사용 (getUserIdentity null 방지)
+          if (useRealtime) {
+            const currentUserId = ownerMeta ? user?.id : undefined;
+            if (enabledMethods.has("list")) {
+              const listResult = await fetchListWithTotal(ctx.db, undefined, currentUserId);
+              ctx.realtime.emit(`${prefix}.list`, listResult);
             }
-
-            const [result] = await inRlsOrPlainTx(ctx.db, async (tx: any) =>
-                tx.update(anyTable)
-                    .set(updateData)
-                    .where(updateWhere)
-                    .returning()
-            );
-
-            // Realtime push (list + get 양쪽) — { data, total } 형태
-            // S5: ownerRls 시 user.id 사용 (getUserIdentity null 방지)
-            if (useRealtime) {
-                const currentUserId = ownerMeta ? user?.id : undefined;
-                if (enabledMethods.has('list')) {
-                    const listResult = await fetchListWithTotal(ctx.db, undefined, currentUserId);
-                    ctx.realtime.emit(`${prefix}.list`, listResult);
-                }
-                if (enabledMethods.has('get')) {
-                    ctx.realtime.emit(`${prefix}.get`, result);
-                }
+            if (enabledMethods.has("get")) {
+              ctx.realtime.emit(`${prefix}.get`, result);
             }
+          }
 
-            return result;
-        }
-    });
+          return result;
+        },
+      });
 
-    // ── remove ────────────────────────────────────
+  // ── remove ────────────────────────────────────
 
-    const removeDef = !enabledMethods.has('remove') ? undefined : mutation(`${prefix}.remove`, {
+  const removeDef = !enabledMethods.has("remove")
+    ? undefined
+    : mutation(`${prefix}.remove`, {
         public: isPublic,
         handler: async (ctx: any, args: any) => {
-            // ownerRls 테이블은 항상 인증 필수
-            const user = (ownerMeta || !isPublic) ? ctx.auth.requireAuth() : null;
-
-            // ── ownerRls Layer 1: remove 시 소유자 검증 ──
-            let deleteWhere: SQL = eq(pk, args.id);
-            if (ownerMeta && user) {
-                // WHERE id = ? AND user_id = ? (타인 데이터 삭제 불가)
-                deleteWhere = and(eq(pk, args.id), eq(ownerMeta.column, user.id))!;
-            }
+          // ownerRls 테이블은 항상 인증 필수
+          const user = ownerMeta || !isPublic ? ctx.auth.requireAuth() : null;
 
-            await inRlsOrPlainTx(ctx.db, async (tx: any) => {
-                if (options?.softDelete) {
-                    const sdField = options.softDelete.field as string;
-                    await tx.update(anyTable)
-                        .set({ [sdField]: new Date() } as any)
-                        .where(deleteWhere);
-                } else {
-                    await tx.delete(anyTable).where(deleteWhere);
-                }
-            });
-
-            // Realtime push — { data, total } 형태
-            // S5: ownerRls 시 user.id 사용
-            if (useRealtime && enabledMethods.has('list')) {
-                const currentUserId = ownerMeta ? user?.id : undefined;
-                const listResult = await fetchListWithTotal(ctx.db, undefined, currentUserId);
-                ctx.realtime.emit(`${prefix}.list`, listResult);
+          // ── ownerRls Layer 1: remove 시 소유자 검증 ──
+          let deleteWhere: SQL = eq(pk, args.id);
+          if (ownerMeta && user) {
+            // WHERE id = ? AND user_id = ? (타인 데이터 삭제 불가)
+            deleteWhere = and(eq(pk, args.id), eq(ownerMeta.column, user.id))!;
+          }
+
+          await inRlsOrPlainTx(ctx.db, async (tx: any) => {
+            if (options?.softDelete) {
+              const sdField = options.softDelete.field as string;
+              await tx
+                .update(anyTable)
+                .set({ [sdField]: new Date() } as any)
+                .where(deleteWhere);
+            } else {
+              await tx.delete(anyTable).where(deleteWhere);
             }
+          });
 
-            return { success: true };
-        }
-    });
+          // Realtime push — { data, total } 형태
+          // S5: ownerRls 시 user.id 사용
+          if (useRealtime && enabledMethods.has("list")) {
+            const currentUserId = ownerMeta ? user?.id : undefined;
+            const listResult = await fetchListWithTotal(ctx.db, undefined, currentUserId);
+            ctx.realtime.emit(`${prefix}.list`, listResult);
+          }
 
-    // 반환 객체는 항상 5개 키를 가지지만, 비활성 메서드는 undefined.
-    // 사용자가 destructure 시 undefined를 받으면 export하지 않으므로
-    // codegen의 레지스트리에 등록되지 않아 api.ts 불일치가 해소됨.
-    return {
-        list: listDef,
-        get: getDef,
-        create: createDef,
-        update: updateDef,
-        remove: removeDef,
-    };
+          return { success: true };
+        },
+      });
+
+  // 반환 객체는 항상 5개 키를 가지지만, 비활성 메서드는 undefined.
+  // 사용자가 destructure 시 undefined를 받으면 export하지 않으므로
+  // codegen의 레지스트리에 등록되지 않아 api.ts 불일치가 해소됨.
+  return {
+    list: listDef,
+    get: getDef,
+    create: createDef,
+    update: updateDef,
+    remove: removeDef,
+  };
 }