@gencow/core 0.1.27 → 0.1.28

package/src/storage-shared.ts

@@ -0,0 +1,74 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+
+/** 파일 업로드 최대 크기: 50MB (하드코딩 — 사용자가 오버라이드 불가) */
+export const MAX_FILE_SIZE = 50 * 1024 * 1024;
+
+/** 기본 스토리지 쿼터: 1GB */
+export const DEFAULT_STORAGE_QUOTA = 1024 * 1024 * 1024;
+
+export interface StorageFile {
+  id: string;
+  name: string;
+  size: number;
+  type: string;
+  path: string;
+}
+
+export interface StoredFile {
+  id: string;
+  name: string;
+  size: number;
+  type: string;
+  buffer: Buffer;
+}
+
+export interface StorageOptions {
+  rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>;
+  storageQuota?: number;
+}
+
+export interface Storage {
+  store(file: File | Blob, filename?: string): Promise<string>;
+  storeBuffer(buffer: Buffer, filename: string, type?: string): Promise<string>;
+  get(storageId: string): Promise<StoredFile | null>;
+  getUrl(storageId: string): string;
+  getMeta(storageId: string): Promise<StorageFile | null>;
+  delete(storageId: string): Promise<void>;
+}
+
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}
+
+export async function loadStorageMeta(params: {
+  storageId: string;
+  dir: string;
+  metaStore: Map<string, StorageFile>;
+}): Promise<StorageFile | null> {
+  const cached = params.metaStore.get(params.storageId);
+  if (cached) {
+    return cached;
+  }
+
+  const filePath = path.join(params.dir, params.storageId);
+  try {
+    const raw = await fs.readFile(`${filePath}.meta`, "utf-8");
+    const parsed = JSON.parse(raw) as { name?: unknown; type?: unknown; size?: unknown };
+    const stat = await fs.stat(filePath);
+    const meta: StorageFile = {
+      id: params.storageId,
+      name: typeof parsed.name === "string" ? parsed.name : params.storageId,
+      size: typeof parsed.size === "number" ? parsed.size : stat.size,
+      type: typeof parsed.type === "string" ? parsed.type : "application/octet-stream",
+      path: filePath,
+    };
+    params.metaStore.set(params.storageId, meta);
+    return meta;
+  } catch {
+    return null;
+  }
+}

package/src/storage.ts

@@ -2,51 +2,15 @@ import * as fs from "fs/promises";
 import * as fsSync from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
+import {
+  DEFAULT_STORAGE_QUOTA,
+  MAX_FILE_SIZE,
+  formatBytes,
+  loadStorageMeta,
+} from "./storage-shared.js";
+import type { Storage, StorageFile, StorageOptions, StoredFile } from "./storage-shared.js";
 
-// ─── Constants ──────────────────────────────────────────
-
-/** 파일 업로드 최대 크기: 50MB (하드코딩 — 사용자가 오버라이드 불가) */
-const MAX_FILE_SIZE = 50 * 1024 * 1024;
-
-/** 기본 스토리지 쿼터: 1GB */
-const DEFAULT_STORAGE_QUOTA = 1024 * 1024 * 1024;
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
-}
-
-// ─── Types ──────────────────────────────────────────────
-
-interface StorageFile {
-  id: string;
-  name: string;
-  size: number;
-  type: string;
-  path: string;
-}
-
-export interface StorageOptions {
-  /** Raw SQL 실행 함수 — DB 자동 기록 + 쿼터 검증에 필요 */
-  rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>;
-  /** 앱별 스토리지 쿼터 (bytes). 0 = 무제한. 기본: 1GB */
-  storageQuota?: number;
-}
-
-export interface Storage {
-  /** Store a file and return a storageId — Convex의 ctx.storage.store() */
-  store(file: File | Blob, filename?: string): Promise<string>;
-  /** Store from raw buffer */
-  storeBuffer(buffer: Buffer, filename: string, type?: string): Promise<string>;
-  /** Get a serving URL for the file — Convex의 ctx.storage.getUrl() */
-  getUrl(storageId: string): string;
-  /** Get file metadata */
-  getMeta(storageId: string): Promise<StorageFile | null>;
-  /** Delete a stored file — Convex의 ctx.storage.delete() */
-  delete(storageId: string): Promise<void>;
-}
+export type { Storage, StorageFile, StorageOptions, StoredFile } from "./storage-shared.js";
 
 // ─── Implementation ─────────────────────────────────────
 
@@ -147,7 +111,6 @@ export function createStorage(dir: string = "./uploads", options?: StorageOption
 
   // Ensure directory exists
   fs.mkdir(dir, { recursive: true }).catch(() => {});
-
   return {
     async store(file: File | Blob, filename?: string): Promise<string> {
       // 크기 제한 검증 (단일 파일)
@@ -248,8 +211,28 @@ export function createStorage(dir: string = "./uploads", options?: StorageOption
       return `/api/storage/${storageId}`;
     },
 
+    async get(storageId: string): Promise<StoredFile | null> {
+      const meta = await loadStorageMeta({ storageId, dir, metaStore });
+      if (!meta) {
+        return null;
+      }
+
+      const buffer = await fs.readFile(meta.path).catch(() => null);
+      if (!buffer) {
+        return null;
+      }
+
+      return {
+        id: meta.id,
+        name: meta.name,
+        size: meta.size,
+        type: meta.type,
+        buffer,
+      };
+    },
+
     async getMeta(storageId: string): Promise<StorageFile | null> {
-      return metaStore.get(storageId) || null;
+      return loadStorageMeta({ storageId, dir, metaStore });
     },
 
     async delete(storageId: string): Promise<void> {

package/src/workflow-types.ts

@@ -1,4 +1,5 @@
 import type { GencowCtx } from "./reactive.js";
+import type { WorkflowDocumentServicesCtx } from "./document-types.js";
 import type { InferArgs } from "./v.js";
 
 export type WorkflowStatus = "pending" | "running" | "completed" | "failed";
@@ -77,9 +78,10 @@ export interface WorkflowResumePayload {
   workflowId: string;
 }
 
-export interface WorkflowCtx extends GencowCtx {
+export interface WorkflowCtx extends Omit<GencowCtx, "services"> {
   workflowId: string;
   workflowName: string;
+  services: GencowCtx["services"] & WorkflowDocumentServicesCtx;
   step<TResult>(name: string, run: () => Promise<TResult>): Promise<TResult>;
   sleep(duration: WorkflowDuration): Promise<void>;
   waitForEvent<TPayload = unknown>(name: string, timeout?: WorkflowDuration): Promise<TPayload>;

package/src/__tests__/auth.test.ts

@@ -1,118 +0,0 @@
-/**
- * packages/core/src/__tests__/auth.test.ts
- *
- * Tests for auth module — AuthCtx, defineAuth, auth-config.
- *
- * Run: bun test packages/core/src/__tests__/auth.test.ts
- */
-
-import { describe, it, expect } from "bun:test";
-import { defineAuth } from "../auth-config.js";
-import type { GencowAuthConfig } from "../auth-config.js";
-
-// ─── defineAuth() ───────────────────────────────────────
-
-describe("defineAuth()", () => {
-  it("빈 설정 객체 반환", () => {
-    const config = defineAuth({});
-    expect(config).toEqual({});
-  });
-
-  it("emailVerification 설정이 그대로 반환된다", () => {
-    const sendFn = async () => {};
-    const config = defineAuth({
-      emailVerification: {
-        sendOnSignUp: true,
-        requireEmailVerification: true,
-        autoSignInAfterVerification: true,
-        sendVerificationEmail: sendFn,
-      },
-    });
-
-    expect(config.emailVerification?.sendOnSignUp).toBe(true);
-    expect(config.emailVerification?.requireEmailVerification).toBe(true);
-    expect(config.emailVerification?.autoSignInAfterVerification).toBe(true);
-    expect(config.emailVerification?.sendVerificationEmail).toBe(sendFn);
-  });
-
-  it("부분 설정도 허용된다", () => {
-    const config = defineAuth({
-      emailVerification: {
-        sendVerificationEmail: async () => {},
-      },
-    });
-
-    expect(config.emailVerification?.sendOnSignUp).toBeUndefined();
-    expect(config.emailVerification?.sendVerificationEmail).toBeDefined();
-  });
-});
-
-// ─── AuthCtx interface 패턴 ─────────────────────────────
-
-describe("AuthCtx 패턴 (mock)", () => {
-  // AuthCtx는 런타임에서 생성되므로, 인터페이스 수준에서 패턴 검증
-
-  it("getUserIdentity — 비로그인 시 null", () => {
-    const authCtx = {
-      getUserIdentity: () => null,
-      requireAuth: () => {
-        throw new Error("Authentication required");
-      },
-    };
-
-    expect(authCtx.getUserIdentity()).toBeNull();
-  });
-
-  it("getUserIdentity — 로그인 시 유저 반환", () => {
-    const user = { id: "u1", email: "test@test.com", name: "Test" };
-    const authCtx = {
-      getUserIdentity: () => user,
-      requireAuth: () => user,
-    };
-
-    expect(authCtx.getUserIdentity()).toEqual(user);
-    expect(authCtx.getUserIdentity()!.id).toBe("u1");
-    expect(authCtx.getUserIdentity()!.email).toBe("test@test.com");
-  });
-
-  it("requireAuth — 비로그인 시 에러 throw", () => {
-    const authCtx = {
-      getUserIdentity: () => null,
-      requireAuth: () => {
-        throw new Error("Authentication required");
-      },
-    };
-
-    expect(() => authCtx.requireAuth()).toThrow("Authentication required");
-  });
-
-  it("requireAuth — 로그인 시 유저 반환 (throw 안 함)", () => {
-    const user = { id: "u2", email: "auth@test.com" };
-    const authCtx = {
-      getUserIdentity: () => user,
-      requireAuth: () => user,
-    };
-
-    expect(() => authCtx.requireAuth()).not.toThrow();
-    expect(authCtx.requireAuth()).toEqual(user);
-  });
-});
-
-// ─── Secure by Default 검증 ─────────────────────────────
-
-describe("Secure by Default — 기본 인증 필수", () => {
-  // query/mutation의 isPublic 기본값은 reactive.test.ts에서 검증됨.
-  // 여기서는 auth 엔드포인트 레벨 패턴만 확인.
-
-  it("공개(public) 쿼리는 auth 없이 실행 가능해야 함", () => {
-    // 이 테스트는 query({ public: true })의 isPublic 플래그 확인
-    // reactive.test.ts의 "Secure by Default" 섹션과 연계
-    const mockQueryDef = { isPublic: true, handler: async () => [] };
-    expect(mockQueryDef.isPublic).toBe(true);
-  });
-
-  it("비공개 쿼리는 기본적으로 auth 필수", () => {
-    const mockQueryDef = { isPublic: false, handler: async () => [] };
-    expect(mockQueryDef.isPublic).toBe(false);
-  });
-});

package/src/__tests__/crons.test.ts

@@ -1,83 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { cronJobs } from "../crons.js";
-
-describe("cronJobs 빌더", () => {
-  test("interval — minutes → cron 패턴 변환", () => {
-    const crons = cronJobs();
-    crons.interval("test", { minutes: 15 }, "test.action");
-    const jobs = crons.getJobs();
-    expect(jobs).toHaveLength(1);
-    expect(jobs[0].name).toBe("test");
-    expect(jobs[0].pattern).toBe("*/15 * * * *");
-    expect(jobs[0].action).toBe("test.action");
-  });
-
-  test("interval — hours → cron 패턴 변환", () => {
-    const crons = cronJobs();
-    crons.interval("hourly", { hours: 6 }, "cleanup");
-    expect(crons.getJobs()[0].pattern).toBe("0 */6 * * *");
-  });
-
-  test("interval — seconds → 6자리 cron 패턴", () => {
-    const crons = cronJobs();
-    crons.interval("fast", { seconds: 30 }, "tick");
-    expect(crons.getJobs()[0].pattern).toBe("*/30 * * * * *");
-  });
-
-  test("daily — 특정 시각", () => {
-    const crons = cronJobs();
-    crons.daily("report", { hour: 9, minute: 30 }, "reports.gen");
-    const job = crons.getJobs()[0];
-    expect(job.pattern).toBe("30 9 * * *");
-  });
-
-  test("daily — minute 기본값 0", () => {
-    const crons = cronJobs();
-    crons.daily("cleanup", { hour: 2 }, "admin.cleanup");
-    expect(crons.getJobs()[0].pattern).toBe("0 2 * * *");
-  });
-
-  test("weekly — 요일 + 시각", () => {
-    const crons = cronJobs();
-    crons.weekly("monday-report", { dayOfWeek: 1, hour: 9 }, "reports.weekly");
-    expect(crons.getJobs()[0].pattern).toBe("0 9 * * 1");
-  });
-
-  test("cron — 직접 패턴 지정", () => {
-    const crons = cronJobs();
-    crons.cron("custom", "0 */2 * * *", "custom.handler");
-    expect(crons.getJobs()[0].pattern).toBe("0 */2 * * *");
-  });
-
-  test("체이닝 지원", () => {
-    const crons = cronJobs();
-    crons
-      .interval("a", { minutes: 5 }, "a.action")
-      .daily("b", { hour: 3 }, "b.action")
-      .cron("c", "0 * * * *", "c.action");
-    expect(crons.getJobs()).toHaveLength(3);
-  });
-
-  test("인라인 핸들러 지원", () => {
-    const crons = cronJobs();
-    const fn = async () => {
-      /* noop */
-    };
-    crons.interval("inline", { minutes: 1 }, fn);
-    expect(typeof crons.getJobs()[0].action).toBe("function");
-  });
-
-  test("getJobs는 복사본 반환 (원본 보호)", () => {
-    const crons = cronJobs();
-    crons.interval("test", { minutes: 1 }, "test");
-    const jobs1 = crons.getJobs();
-    const jobs2 = crons.getJobs();
-    expect(jobs1).not.toBe(jobs2); // 서로 다른 참조
-    expect(jobs1).toEqual(jobs2); // 내용은 동일
-  });
-
-  test("interval — 옵션 없으면 에러", () => {
-    const crons = cronJobs();
-    expect(() => crons.interval("bad", {}, "bad")).toThrow("minutes, hours, 또는 seconds");
-  });
-});

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);
-  });
-});