@gencow/core 0.1.12 → 0.1.14

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

@@ -0,0 +1,253 @@
+/**
+ * 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";
+import {
+    query,
+    mutation,
+    getRegisteredQueries,
+    getRegisteredMutations,
+    getQueryDef,
+} from "../reactive";
+
+// ─── 테스트용 테이블 정의 ─────────────────────────────────────────────
+
+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", {
+            invalidates: ["cg_digests.list"],
+            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);
+    });
+});