@gencow/core 0.1.27 → 0.1.29

package/src/__tests__/crud-codegen-integration.test.ts

@@ -1,246 +0,0 @@
-/**
- * packages/core/src/__tests__/crud-codegen-integration.test.ts
- *
- * crud() → 레지스트리 등록 → codegen 인식 통합 테스트.
- *
- * 이 테스트의 존재 이유:
- *   2026-04-02 사고: crud()가 query/mutation을 레지스트리에 자동 등록하지만,
- *   codegen(gencow-extract.ts)이 getRegisteredQueries()/getRegisteredMutations()를
- *   통해 이를 인식하는 전체 파이프라인이 검증되지 않았음.
- *   결과: 사용자 모듈이 crud()를 사용하면 api.ts에 CRUD 엔드포인트가 누락됨.
- *
- * 검증 항목:
- *   1. crud() 호출 후 getRegisteredQueries()에 {prefix}.list, {prefix}.get 포함
- *   2. crud() 호출 후 getRegisteredMutations()에 {prefix}.create/update/remove 포함
- *   3. 수동 query()/mutation()과 crud() 혼용 시 양쪽 모두 레지스트리에 존재
- *   4. public/private 상태가 레지스트리에 정확히 반영
- *   5. 여러 테이블의 crud()를 동시 호출해도 충돌 없음
- *
- * Run: bun test packages/core/src/__tests__/crud-codegen-integration.test.ts
- *
- * @see docs/analysis/analysis-test032-gencow-crud-api-mismatch.md
- */
-
-import { describe, it, expect, beforeAll } from "bun:test";
-import { pgTable, serial, text, timestamp } from "drizzle-orm/pg-core";
-
-import { crud } from "../crud.js";
-import { query, mutation, getRegisteredQueries, getRegisteredMutations, getQueryDef } from "../reactive.js";
-
-// ─── 테스트용 테이블 정의 ─────────────────────────────────────────────
-
-const keywords = pgTable("cg_keywords", {
-  id: serial("id").primaryKey(),
-  keyword: text("keyword").notNull(),
-  userId: text("user_id"),
-  createdAt: timestamp("created_at").defaultNow(),
-});
-
-const crawlLogs = pgTable("cg_crawl_logs", {
-  id: serial("id").primaryKey(),
-  status: text("status"),
-  createdAt: timestamp("created_at").defaultNow(),
-});
-
-const digests = pgTable("cg_digests", {
-  id: serial("id").primaryKey(),
-  title: text("title"),
-  content: text("content"),
-  createdAt: timestamp("created_at").defaultNow(),
-});
-
-const appSettings = pgTable("cg_app_settings", {
-  id: serial("id").primaryKey(),
-  key: text("key"),
-  value: text("value"),
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// 1. crud() → 레지스트리 등록 → codegen 인식 전체 파이프라인
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("crud() → codegen 통합 — 다중 테이블", () => {
-  beforeAll(() => {
-    // test032 패턴 재현: 4개 모듈이 각각 crud() 호출
-    crud(keywords, { public: true });
-    crud(crawlLogs, { public: true });
-    crud(digests, { public: true });
-    crud(appSettings, { public: true });
-  });
-
-  it("4개 테이블의 list/get query가 모두 레지스트리에 등록된다", () => {
-    const queries = getRegisteredQueries();
-
-    // 각 테이블의 list + get = 8개
-    expect(queries).toContain("cg_keywords.list");
-    expect(queries).toContain("cg_keywords.get");
-    expect(queries).toContain("cg_crawl_logs.list");
-    expect(queries).toContain("cg_crawl_logs.get");
-    expect(queries).toContain("cg_digests.list");
-    expect(queries).toContain("cg_digests.get");
-    expect(queries).toContain("cg_app_settings.list");
-    expect(queries).toContain("cg_app_settings.get");
-  });
-
-  it("4개 테이블의 create/update/remove mutation이 모두 레지스트리에 등록된다", () => {
-    const mutations = getRegisteredMutations();
-    const names = mutations.map((m) => m.name);
-
-    // 각 테이블의 create + update + remove = 12개
-    expect(names).toContain("cg_keywords.create");
-    expect(names).toContain("cg_keywords.update");
-    expect(names).toContain("cg_keywords.remove");
-    expect(names).toContain("cg_crawl_logs.create");
-    expect(names).toContain("cg_crawl_logs.update");
-    expect(names).toContain("cg_crawl_logs.remove");
-    expect(names).toContain("cg_digests.create");
-    expect(names).toContain("cg_digests.update");
-    expect(names).toContain("cg_digests.remove");
-    expect(names).toContain("cg_app_settings.create");
-    expect(names).toContain("cg_app_settings.update");
-    expect(names).toContain("cg_app_settings.remove");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// 2. crud() + 수동 query/mutation 혼용 — 양쪽 모두 codegen에 포함
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("crud() + 수동 query/mutation 혼용", () => {
-  beforeAll(() => {
-    // crud로 자동 등록
-    const articlesTable = pgTable("cg_articles", {
-      id: serial("id").primaryKey(),
-      title: text("title"),
-      createdAt: timestamp("created_at").defaultNow(),
-    });
-    crud(articlesTable, { public: true });
-
-    // 수동으로 추가 등록 (test032의 digestsModule.generate 패턴)
-    query("cg_digests.latest", {
-      public: true,
-      handler: async (ctx) => {
-        return { id: 1, title: "latest" };
-      },
-    });
-
-    mutation("cg_digests.generate", {
-      public: true,
-      handler: async (ctx) => {
-        return { success: true };
-      },
-    });
-  });
-
-  it("crud 등록 + 수동 등록이 모두 getRegisteredQueries()에 포함된다", () => {
-    const queries = getRegisteredQueries();
-
-    // crud 자동 등록
-    expect(queries).toContain("cg_articles.list");
-    expect(queries).toContain("cg_articles.get");
-
-    // 수동 등록
-    expect(queries).toContain("cg_digests.latest");
-  });
-
-  it("crud 등록 + 수동 등록이 모두 getRegisteredMutations()에 포함된다", () => {
-    const mutations = getRegisteredMutations();
-    const names = mutations.map((m) => m.name);
-
-    // crud 자동 등록
-    expect(names).toContain("cg_articles.create");
-    expect(names).toContain("cg_articles.update");
-    expect(names).toContain("cg_articles.remove");
-
-    // 수동 등록
-    expect(names).toContain("cg_digests.generate");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// 3. public/private 상태 정확성 — codegen이 isPublic 기반으로 auth 분기
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("crud() isPublic 상태 — codegen auth 분기 정확성", () => {
-  beforeAll(() => {
-    const publicTable = pgTable("cg_public_data", {
-      id: serial("id").primaryKey(),
-      name: text("name"),
-    });
-    const privateTable = pgTable("cg_private_data", {
-      id: serial("id").primaryKey(),
-      name: text("name"),
-    });
-
-    crud(publicTable, { public: true });
-    crud(privateTable); // default: auth 필수
-  });
-
-  it("public: true 테이블의 모든 엔드포인트가 isPublic === true", () => {
-    const listDef = getQueryDef("cg_public_data.list");
-    const getDef = getQueryDef("cg_public_data.get");
-
-    expect(listDef!.isPublic).toBe(true);
-    expect(getDef!.isPublic).toBe(true);
-
-    const mutations = getRegisteredMutations();
-    const createDef = mutations.find((m) => m.name === "cg_public_data.create");
-    expect(createDef!.isPublic).toBe(true);
-  });
-
-  it("기본(private) 테이블의 모든 엔드포인트가 isPublic === false", () => {
-    const listDef = getQueryDef("cg_private_data.list");
-    const getDef = getQueryDef("cg_private_data.get");
-
-    expect(listDef!.isPublic).toBe(false);
-    expect(getDef!.isPublic).toBe(false);
-
-    const mutations = getRegisteredMutations();
-    const createDef = mutations.find((m) => m.name === "cg_private_data.create");
-    expect(createDef!.isPublic).toBe(false);
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// 4. codegen 시뮬레이션 — getRegisteredQueries/Mutations로 api.ts 생성
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("codegen 시뮬레이션 — api.ts 생성 가능 여부", () => {
-  it("getRegisteredQueries()로 모든 query key를 열거할 수 있다", () => {
-    const queries = getRegisteredQueries();
-    expect(queries.length).toBeGreaterThan(0);
-
-    // 모든 query key가 "namespace.action" 패턴이어야 함
-    for (const key of queries) {
-      expect(key).toMatch(/^[a-z_]+\.[a-z_]+$/i);
-    }
-  });
-
-  it("getRegisteredMutations()로 모든 mutation을 열거할 수 있다", () => {
-    const mutations = getRegisteredMutations();
-    expect(mutations.length).toBeGreaterThan(0);
-
-    // 모든 mutation이 name + handler를 가져야 함
-    for (const mut of mutations) {
-      expect(mut.name).toBeTruthy();
-      expect(typeof mut.handler).toBe("function");
-    }
-  });
-
-  it("getQueryDef()로 개별 query의 argsSchema에 접근할 수 있다", () => {
-    const listDef = getQueryDef("cg_keywords.list");
-    expect(listDef).toBeDefined();
-    // list handler에는 argsSchema가 있음 (limit, offset, sort, filters)
-    expect(listDef!.handler).toBeDefined();
-  });
-
-  it("codegen 대상 query/mutation 총 개수가 올바르다", () => {
-    const queries = getRegisteredQueries();
-    const mutations = getRegisteredMutations();
-
-    // 최소 8개 query (4테이블 × list+get) + 수동 1개 + 이전 테스트들
-    expect(queries.length).toBeGreaterThanOrEqual(8);
-    // 최소 12개 mutation (4테이블 × create+update+remove) + 수동 1개
-    expect(mutations.length).toBeGreaterThanOrEqual(12);
-  });
-});

package/src/__tests__/crud-owner-rls.test.ts

@@ -1,387 +0,0 @@
-/**
- * packages/core/src/__tests__/crud-owner-rls.test.ts
- *
- * ownerRls + crud() 통합 테스트 — 2-Layer 방어 Layer 1 검증
- *
- * 검증 항목:
- *   1. 격리: 타 사용자 데이터 접근 차단 (list, get, update, remove)
- *   2. 자동주입: create 시 userId 강제 설정 (사용자 입력 무시)
- *   3. read: "public": SELECT 필터 생략 + CUD 소유자 강제
- *   4. 하위호환: ownerRls 미적용 테이블은 기존 동작 100% 유지
- *
- * Run: bun test packages/core/src/__tests__/crud-owner-rls.test.ts
- */
-
-import { describe, it, expect } from "bun:test";
-import { pgTable, serial, text, timestamp, pgPolicy } from "drizzle-orm/pg-core";
-import { sql } from "drizzle-orm";
-import { crud } from "../crud.js";
-import { ownerRls, getOwnerRlsMeta, registerOwnerRls } from "../rls.js";
-import { getQueryDef, getRegisteredMutations } from "../reactive.js";
-
-// ─── 테스트 테이블 정의 ────────────────────────────────────────────────────
-
-// ownerRls 적용 테이블
-const rlsTasks = pgTable(
-  "rls_tasks",
-  {
-    id: serial("id").primaryKey(),
-    title: text("title").notNull(),
-    userId: text("user_id").notNull(),
-    createdAt: timestamp("created_at").defaultNow(),
-    updatedAt: timestamp("updated_at").defaultNow(),
-  },
-  (t) => ownerRls(t.userId),
-);
-
-// ownerRls(read: "public") 테이블
-const rlsPosts = pgTable(
-  "rls_posts",
-  {
-    id: serial("id").primaryKey(),
-    content: text("content").notNull(),
-    userId: text("user_id").notNull(),
-    createdAt: timestamp("created_at").defaultNow(),
-  },
-  (t) => ownerRls(t.userId, { read: "public" }),
-);
-
-// ownerRls 미적용 테이블 (하위호환 검증)
-const plainItems = pgTable("plain_items", {
-  id: serial("id").primaryKey(),
-  name: text("name"),
-  userId: text("user_id"),
-  createdAt: timestamp("created_at").defaultNow(),
-});
-
-// ─── Mock 유틸 ─────────────────────────────────────────────────────────
-
-function createMockCtx(userId: string, mockData: any[] = []) {
-  const dataChain: any = {
-    from: () => dataChain,
-    where: () => dataChain,
-    orderBy: () => dataChain,
-    limit: (n?: number) =>
-      n === 1
-        ? Promise.resolve(mockData.slice(0, 1)) // get handler: .limit(1) → 단일 행 반환
-        : dataChain, // list handler: .limit(n).offset(m)
-    offset: () => Promise.resolve(mockData),
-  };
-  const countChain = {
-    from: () => countChain,
-    where: () => Promise.resolve([{ count: mockData.length }]),
-  };
-
-  let capturedValues: any = null;
-  let capturedWhereArg: any = null;
-  const emitted: { key: string; data: any }[] = [];
-
-  return {
-    ctx: {
-      auth: {
-        requireAuth: () => ({ id: userId, email: `${userId}@test.com` }),
-        getUserIdentity: () => ({ id: userId }),
-        getSession: () => null,
-      },
-      db: {
-        select: (selectArg?: any) => {
-          if (selectArg && typeof selectArg === "object" && "count" in selectArg) {
-            return countChain;
-          }
-          return dataChain;
-        },
-        insert: () => ({
-          values: (v: any) => {
-            capturedValues = v;
-            return { returning: () => Promise.resolve([{ ...v, id: 1 }]) };
-          },
-        }),
-        update: () => ({
-          set: (data: any) => ({
-            where: (w: any) => {
-              capturedWhereArg = w;
-              return { returning: () => Promise.resolve([{ ...data, id: 1 }]) };
-            },
-          }),
-        }),
-        delete: () => ({
-          where: (w: any) => {
-            capturedWhereArg = w;
-            return Promise.resolve();
-          },
-        }),
-      },
-      realtime: {
-        emit: (key: string, data: any) => emitted.push({ key, data }),
-      },
-    },
-    getCapturedValues: () => capturedValues,
-    getCapturedWhere: () => capturedWhereArg,
-    emitted,
-  };
-}
-
-function createUnauthCtx(mockData: any[] = []) {
-  const dataChain = {
-    from: () => dataChain,
-    where: () => dataChain,
-    orderBy: () => dataChain,
-    limit: () => dataChain,
-    offset: () => Promise.resolve(mockData),
-  };
-  const countChain = {
-    from: () => countChain,
-    where: () => Promise.resolve([{ count: mockData.length }]),
-  };
-
-  return {
-    auth: {
-      requireAuth: () => {
-        throw new Error("Unauthorized");
-      },
-      getUserIdentity: () => null,
-      getSession: () => null,
-    },
-    db: {
-      select: (selectArg?: any) => {
-        if (selectArg && typeof selectArg === "object" && "count" in selectArg) {
-          return countChain;
-        }
-        return dataChain;
-      },
-    },
-    realtime: {
-      emit: () => {},
-    },
-  };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Phase 1 검증: ownerRls() 메타데이터
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("ownerRls() — 메타데이터 레지스트리", () => {
-  it("ownerRls 적용 테이블에서 메타데이터를 감지한다", () => {
-    // ownerRls()가 호출된 rlsTasks 테이블에서 WeakMap으로 건 못 찾더라도
-    // crud()가 getTableConfig().policies로 fallback 감지
-    // 여기서는 registerOwnerRls를 직접 호출하여 테스트
-    registerOwnerRls(rlsTasks, { columnName: "user_id", readPublic: false });
-
-    const meta = getOwnerRlsMeta(rlsTasks);
-    expect(meta).toBeDefined();
-    expect(meta!.columnName).toBe("user_id");
-    expect(meta!.readPublic).toBe(false);
-  });
-
-  it("read: public 옵션이 메타데이터에 반영된다", () => {
-    registerOwnerRls(rlsPosts, { columnName: "user_id", readPublic: true });
-
-    const meta = getOwnerRlsMeta(rlsPosts);
-    expect(meta).toBeDefined();
-    expect(meta!.readPublic).toBe(true);
-  });
-
-  it("ownerRls 미적용 테이블은 undefined 반환", () => {
-    const meta = getOwnerRlsMeta(plainItems);
-    expect(meta).toBeUndefined();
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Phase 2 검증: crud() ownerRls 감지 + 필터 주입
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("crud() + ownerRls — 데이터 격리", () => {
-  // 초기화: crud 등록
-  crud(rlsTasks);
-  crud(rlsPosts);
-  crud(plainItems);
-
-  // ── list 격리 ──
-
-  it("list: ownerRls 테이블에서 requireAuth가 호출된다", async () => {
-    const listDef = getQueryDef("rls_tasks.list");
-    expect(listDef).toBeDefined();
-
-    const { ctx } = createMockCtx("user-A", []);
-    // 에러 없이 실행되면 requireAuth 호출 성공
-    const result = await listDef!.handler(ctx, {});
-    expect(result).toHaveProperty("data");
-    expect(result).toHaveProperty("total");
-  });
-
-  it("list: ownerRls 테이블은 인증 없이 접근 불가", async () => {
-    const listDef = getQueryDef("rls_tasks.list");
-    const unauthCtx = createUnauthCtx();
-
-    await expect(listDef!.handler(unauthCtx, {})).rejects.toThrow("Unauthorized");
-  });
-
-  // ── get 격리 ──
-
-  it("get: ownerRls 테이블에서 requireAuth가 호출된다", async () => {
-    const getDef = getQueryDef("rls_tasks.get");
-    expect(getDef).toBeDefined();
-
-    const { ctx } = createMockCtx("user-A", [{ id: 1, title: "test", userId: "user-A" }]);
-    const result = await getDef!.handler(ctx, { id: 1 });
-    // null 또는 데이터 반환 (mock이므로 체이닝 결과)
-    // 핵심: 에러 없이 실행되면 성공
-  });
-
-  // ── create 자동 주입 ──
-
-  it("create: ownerRls 테이블에서 userId가 인증 사용자로 강제 설정된다", async () => {
-    const mutations = getRegisteredMutations();
-    const createDef = mutations.find((m: any) => m.name === "rls_tasks.create");
-    expect(createDef).toBeDefined();
-
-    const { ctx, getCapturedValues } = createMockCtx("user-A");
-    await createDef!.handler(ctx, { title: "New Task" });
-
-    // userId가 인증된 사용자 ID로 강제 설정됨 (JS 프로퍼티명 사용)
-    const values = getCapturedValues();
-    expect(values).toBeDefined();
-    expect(values.userId).toBe("user-A");
-  });
-
-  it("create: 타인 user_id 주입 시도는 거부되고 insert까지 가지 않음 (보안)", async () => {
-    const mutations = getRegisteredMutations();
-    const createDef = mutations.find((m: any) => m.name === "rls_tasks.create");
-
-    const { ctx, getCapturedValues } = createMockCtx("user-A");
-    // 해커가 user_id를 "hacker-id"로 조작 시도 — Layer 1은 즉시 Forbidden (덮어쓰기 전 차단)
-    await expect(createDef!.handler(ctx, { title: "Spoofed", user_id: "hacker-id" })).rejects.toThrow(
-      "Forbidden: cannot create resource for another user",
-    );
-
-    expect(getCapturedValues()).toBeNull();
-  });
-
-  // ── update 격리 ──
-
-  it("update: ownerRls 테이블에서 userId 변경 시도가 차단된다", async () => {
-    const mutations = getRegisteredMutations();
-    const updateDef = mutations.find((m: any) => m.name === "rls_tasks.update");
-    expect(updateDef).toBeDefined();
-
-    // update에서는 set()에 전달되는 데이터에서 user_id 키가 삭제되어야 함
-    let capturedSetData: any = null;
-    const mockCtx = {
-      auth: {
-        requireAuth: () => ({ id: "user-A", email: "a@test.com" }),
-        getUserIdentity: () => ({ id: "user-A" }),
-      },
-      db: {
-        select: (selectArg?: any) => {
-          if (selectArg && typeof selectArg === "object" && "count" in selectArg) {
-            return { from: () => ({ where: () => Promise.resolve([{ count: 0 }]) }) };
-          }
-          return {
-            from: () => ({ where: () => ({ orderBy: () => Promise.resolve([]) }) }),
-          };
-        },
-        update: () => ({
-          set: (data: any) => {
-            capturedSetData = data;
-            return {
-              where: () => ({
-                returning: () => Promise.resolve([{ id: 1, title: "Updated" }]),
-              }),
-            };
-          },
-        }),
-      },
-      realtime: { emit: () => {} },
-    };
-
-    await updateDef!.handler(mockCtx, {
-      id: 1,
-      title: "Updated",
-      user_id: "hacker-id", // userId 변경 시도
-    });
-
-    // user_id가 set 데이터에서 삭제되었는지 확인 (JS 프로퍼티명 + DB명 양쪽)
-    expect(capturedSetData).toBeDefined();
-    expect(capturedSetData).not.toHaveProperty("userId");
-    expect(capturedSetData).not.toHaveProperty("user_id");
-    expect(capturedSetData.title).toBe("Updated");
-  });
-
-  // ── remove 격리 ──
-
-  it("remove: ownerRls 테이블에서 requireAuth가 호출된다", async () => {
-    const mutations = getRegisteredMutations();
-    const removeDef = mutations.find((m: any) => m.name === "rls_tasks.remove");
-    expect(removeDef).toBeDefined();
-
-    const { ctx } = createMockCtx("user-A");
-    const result = await removeDef!.handler(ctx, { id: 1 });
-    expect(result).toEqual({ success: true });
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// read: "public" 테스트
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("crud() + ownerRls(read: 'public') — 공개 읽기", () => {
-  it("list: 인증 없이 접근 가능 (read: public이므로 auth skip)", async () => {
-    // rlsPosts는 ownerRls(userId, { read: "public" })
-    // readPublic: true → list에서 userId 필터 생략
-    const listDef = getQueryDef("rls_posts.list");
-    expect(listDef).toBeDefined();
-
-    // crud는 isPublic=false로 생성되었으므로 requireAuth는 호출됨
-    // 하지만 readPublic=true이므로 userId 필터는 추가되지 않음
-    const { ctx } = createMockCtx("user-A", [{ id: 1, content: "hello" }]);
-    const result = await listDef!.handler(ctx, {});
-    expect(result.data).toHaveLength(1);
-  });
-
-  it("create: 인증 필수 + userId 강제 주입", async () => {
-    const mutations = getRegisteredMutations();
-    const createDef = mutations.find((m: any) => m.name === "rls_posts.create");
-    expect(createDef).toBeDefined();
-
-    const { ctx, getCapturedValues } = createMockCtx("user-B");
-    await createDef!.handler(ctx, { content: "Public post" });
-
-    const values = getCapturedValues();
-    expect(values.userId).toBe("user-B");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// 하위호환 테스트 — ownerRls 미적용 테이블
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("crud() — ownerRls 미적용 하위호환", () => {
-  it("ownerRls 없는 테이블에서 기존 userId 자동 주입 동작 유지", async () => {
-    const mutations = getRegisteredMutations();
-    const createDef = mutations.find((m: any) => m.name === "plain_items.create");
-    expect(createDef).toBeDefined();
-
-    const { ctx, getCapturedValues } = createMockCtx("user-C");
-    await createDef!.handler(ctx, { name: "Widget" });
-
-    const values = getCapturedValues();
-    // ownerRls 미적용 → 기존 자동 주입 로직: userId 컬럼이 있고 인증됐으면 주입
-    expect(values.userId).toBe("user-C");
-  });
-
-  it("ownerRls 없는 테이블의 list는 userId 필터 없이 전체 반환", async () => {
-    const listDef = getQueryDef("plain_items.list");
-    expect(listDef).toBeDefined();
-
-    const allData = [
-      { id: 1, name: "A", userId: "user-A" },
-      { id: 2, name: "B", userId: "user-B" },
-    ];
-    const { ctx } = createMockCtx("user-A", allData);
-    const result = await listDef!.handler(ctx, {});
-
-    // ownerRls 미적용 → 모든 데이터 반환 (기존 동작)
-    expect(result.data).toHaveLength(2);
-  });
-});