@gencow/core 0.1.13 → 0.1.14

package/dist/crud.js

@@ -94,11 +94,12 @@ export function crud(table, options) {
         return conditions.length > 0 ? and(...conditions) : undefined;
     }
     // ── 내부 헬퍼: list+count 데이터 가져오기 (realtime push용 재사용) ──
+    // 순차 실행: 소규모 커넥션 풀 환경에서 동시 점유 방지
+    // ⚠️ limit/offset 없이 전체 SELECT — 대량 데이터 시 성능 저하 주의
+    // TODO(P2): realtime emit 시 invalidation 메시지만 전송하고 클라이언트가 re-fetch하는 패턴 검토
     async function fetchListWithTotal(db, whereClause) {
-        const [data, countResult] = await Promise.all([
-            db.select().from(anyTable).where(whereClause).orderBy(desc(defaultOrderCol)),
-            db.select({ count: drizzleCount() }).from(anyTable).where(whereClause),
-        ]);
+        const data = await db.select().from(anyTable).where(whereClause).orderBy(desc(defaultOrderCol));
+        const countResult = await db.select({ count: drizzleCount() }).from(anyTable).where(whereClause);
         return { data, total: Number(countResult[0]?.count ?? 0) };
     }
     // ── list ──────────────────────────────────────
@@ -128,18 +129,18 @@ export function crud(table, options) {
             else {
                 orderByClause = desc(defaultOrderCol);
             }
-            // SELECT + COUNT 병렬 실행
-            const [results, countResult] = await Promise.all([
-                ctx.db.select()
-                    .from(anyTable)
-                    .where(whereClause)
-                    .orderBy(orderByClause)
-                    .limit(limit)
-                    .offset(offset),
-                ctx.db.select({ count: drizzleCount() })
-                    .from(anyTable)
-                    .where(whereClause),
-            ]);
+            // SELECT + COUNT 순차 실행 — 소규모 커넥션 풀 환경에서 동시 점유 방지
+            // Note: data←→count 사이 INSERT/DELETE 시 total 불일치 가능 (BaaS 단일사용자/저부하에서 무시 가능)
+            // TODO(P2): 대규모 시 db.transaction() 래핑 검토
+            const results = await ctx.db.select()
+                .from(anyTable)
+                .where(whereClause)
+                .orderBy(orderByClause)
+                .limit(limit)
+                .offset(offset);
+            const countResult = await ctx.db.select({ count: drizzleCount() })
+                .from(anyTable)
+                .where(whereClause);
             return {
                 data: results,
                 total: Number(countResult[0]?.count ?? 0),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gencow/core",
-    "version": "0.1.13",
+    "version": "0.1.14",
     "description": "Gencow core library — defineQuery, defineMutation, reactive subscriptions",
     "type": "module",
     "main": "dist/index.js",

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

package/src/__tests__/dist-exports.test.ts

@@ -0,0 +1,170 @@
+/**
+ * packages/core/src/__tests__/dist-exports.test.ts
+ *
+ * dist/ 빌드 산출물의 필수 export 검증 — npm publish 전 안전망.
+ *
+ * 이 테스트의 존재 이유:
+ *   2026-04-02 사고: 소스코드에 crud v2가 완전 구현되어 있었으나,
+ *   dist/index.js에 `crud` export가 누락된 구버전이 npm에 배포됨.
+ *   crud.test.ts(16 pass)가 src/crud.ts를 직접 import하므로
+ *   dist/ 빌드 결과물의 정합성은 검증하지 못했음.
+ *
+ * 검증 항목:
+ *   1. dist/index.js 파일 존재
+ *   2. 필수 named export 존재 (crud, query, mutation, v, ...)
+ *   3. gencowCrud deprecated alias 존재 (하위호환)
+ *   4. crud가 실제 함수인지 (typeof === "function")
+ *   5. dist/index.js의 crud와 src/crud.ts의 crud가 동일 함수인지
+ *
+ * Run: bun test packages/core/src/__tests__/dist-exports.test.ts
+ *
+ * @see docs/analysis/analysis-test032-gencow-crud-api-mismatch.md
+ */
+
+import { describe, it, expect } from "bun:test";
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CORE_ROOT = resolve(__dirname, "../..");
+const DIST_INDEX = resolve(CORE_ROOT, "dist/index.js");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 1. dist/ 파일 존재 확인
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("dist/ 빌드 산출물 존재", () => {
+    it("dist/index.js 파일이 존재한다", () => {
+        expect(existsSync(DIST_INDEX)).toBe(true);
+    });
+
+    it("dist/crud.js 파일이 존재한다", () => {
+        expect(existsSync(resolve(CORE_ROOT, "dist/crud.js"))).toBe(true);
+    });
+
+    it("dist/reactive.js 파일이 존재한다", () => {
+        expect(existsSync(resolve(CORE_ROOT, "dist/reactive.js"))).toBe(true);
+    });
+
+    it("dist/v.js 파일이 존재한다", () => {
+        expect(existsSync(resolve(CORE_ROOT, "dist/v.js"))).toBe(true);
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 2. 필수 named export 존재 확인
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("dist/index.js 필수 export", () => {
+    let distModule: Record<string, unknown>;
+
+    // dist/index.js를 dynamic import (빌드 결과물 검증)
+    it("dist/index.js를 import할 수 있다", async () => {
+        distModule = await import(DIST_INDEX);
+        expect(distModule).toBeDefined();
+    });
+
+    // ── Core API exports ──────────────────────────────────────
+
+    it("crud export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.crud).toBeDefined();
+        expect(typeof distModule.crud).toBe("function");
+    });
+
+    it("gencowCrud deprecated alias가 존재하고 crud와 동일하다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.gencowCrud).toBeDefined();
+        expect(distModule.gencowCrud).toBe(distModule.crud);
+    });
+
+    it("query export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.query).toBeDefined();
+        expect(typeof distModule.query).toBe("function");
+    });
+
+    it("mutation export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.mutation).toBeDefined();
+        expect(typeof distModule.mutation).toBe("function");
+    });
+
+    it("v export가 존재하고 객체이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.v).toBeDefined();
+        expect(typeof distModule.v).toBe("object");
+    });
+
+    it("httpAction export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.httpAction).toBeDefined();
+        expect(typeof distModule.httpAction).toBe("function");
+    });
+
+    // ── Registry exports (codegen 의존) ────────────────────────
+
+    it("getRegisteredQueries export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.getRegisteredQueries).toBeDefined();
+        expect(typeof distModule.getRegisteredQueries).toBe("function");
+    });
+
+    it("getRegisteredMutations export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.getRegisteredMutations).toBeDefined();
+        expect(typeof distModule.getRegisteredMutations).toBe("function");
+    });
+
+    // ── RLS + Auth exports ─────────────────────────────────────
+
+    it("ownerRls export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.ownerRls).toBeDefined();
+    });
+
+    it("defineAuth export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.defineAuth).toBeDefined();
+    });
+
+    it("cronJobs export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.cronJobs).toBeDefined();
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 3. dist/crud.js가 v2 구현인지 확인 (커링 구조가 아닌지)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("dist/crud.js — v2 구현 검증", () => {
+    it("crud(table) 시그니처이다 (커링 gencowCrud(db)(table) 아님)", async () => {
+        const distModule = await import(DIST_INDEX);
+        const { crud } = distModule;
+
+        // v2: crud(table, options?) → { list, get, create, update, remove }
+        // 구버전: gencowCrud(db) → (table, options?) → { create, findById, list, ... }
+
+        // 실제 Drizzle 테이블로 테스트
+        const { pgTable, serial, text } = await import("drizzle-orm/pg-core");
+        const testTable = pgTable("dist_smoke_test", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+        });
+
+        const result = crud(testTable, { public: true });
+
+        // v2는 { list, get, create, update, remove } 반환
+        expect(result).toHaveProperty("list");
+        expect(result).toHaveProperty("get");
+        expect(result).toHaveProperty("create");
+        expect(result).toHaveProperty("update");
+        expect(result).toHaveProperty("remove");
+
+        // 구버전(커링)은 함수를 반환하므로 이 검증이 실패함
+        expect(typeof result).toBe("object");
+        expect(typeof result.list).not.toBe("undefined");
+    });
+});

package/src/crud.ts

@@ -137,11 +137,12 @@ export function crud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
     }
 
     // ── 내부 헬퍼: list+count 데이터 가져오기 (realtime push용 재사용) ──
+    // 순차 실행: 소규모 커넥션 풀 환경에서 동시 점유 방지
+    // ⚠️ limit/offset 없이 전체 SELECT — 대량 데이터 시 성능 저하 주의
+    // TODO(P2): realtime emit 시 invalidation 메시지만 전송하고 클라이언트가 re-fetch하는 패턴 검토
     async function fetchListWithTotal(db: any, whereClause?: SQL) {
-        const [data, countResult] = await Promise.all([
-            db.select().from(anyTable).where(whereClause).orderBy(desc(defaultOrderCol)),
-            db.select({ count: drizzleCount() }).from(anyTable).where(whereClause),
-        ]);
+        const data = await db.select().from(anyTable).where(whereClause).orderBy(desc(defaultOrderCol));
+        const countResult = await db.select({ count: drizzleCount() }).from(anyTable).where(whereClause);
         return { data, total: Number(countResult[0]?.count ?? 0) };
     }
 
@@ -175,18 +176,18 @@ export function crud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
                 orderByClause = desc(defaultOrderCol);
             }
 
-            // SELECT + COUNT 병렬 실행
-            const [results, countResult] = await Promise.all([
-                ctx.db.select()
-                    .from(anyTable)
-                    .where(whereClause)
-                    .orderBy(orderByClause)
-                    .limit(limit)
-                    .offset(offset),
-                ctx.db.select({ count: drizzleCount() })
-                    .from(anyTable)
-                    .where(whereClause),
-            ]);
+            // SELECT + COUNT 순차 실행 — 소규모 커넥션 풀 환경에서 동시 점유 방지
+            // Note: data←→count 사이 INSERT/DELETE 시 total 불일치 가능 (BaaS 단일사용자/저부하에서 무시 가능)
+            // TODO(P2): 대규모 시 db.transaction() 래핑 검토
+            const results = await ctx.db.select()
+                .from(anyTable)
+                .where(whereClause)
+                .orderBy(orderByClause)
+                .limit(limit)
+                .offset(offset);
+            const countResult = await ctx.db.select({ count: drizzleCount() })
+                .from(anyTable)
+                .where(whereClause);
 
             return {
                 data: results,