@gencow/core 0.1.13 → 0.1.15

package/src/__tests__/crud.test.ts

@@ -26,7 +26,7 @@ import { pgTable, serial, text, timestamp } from "drizzle-orm/pg-core";
 
 // ─── crud import ───────────────────────────────────────────────────────
 
-import { crud } from "../crud";
+import { crud, parseFilterNode, applyFilterOp } from "../crud";
 
 // ─── 테스트 테이블 정의 ────────────────────────────────────────────────────
 
@@ -525,3 +525,423 @@ describe("crud() — allowedFilters", () => {
         expect(result2).toHaveProperty("data");
     });
 });
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 11. v3 Filter Engine — parseFilterNode 직접 테스트 (spec TC1~5)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("v3 Filter Engine — parseFilterNode", () => {
+    // TC1: 하위 호환성 (Implicit eq)
+    it("TC1: 단순 key-value는 암묵적 eq로 파싱된다 (하위호환)", () => {
+        const table = pgTable("tc1_test", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+        });
+
+        const result = parseFilterNode({ status: "active" }, table);
+        expect(result).toBeDefined();
+    });
+
+    it("TC1: 여러 key-value 동시 사용 시 모두 AND 결합된다", () => {
+        const table = pgTable("tc1b_test", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            category: text("category"),
+        });
+
+        const result = parseFilterNode({ status: "active", category: "tech" }, table);
+        expect(result).toBeDefined();
+    });
+
+    // TC2: 다중 논리망 (Nested OR & AND)
+    it("TC2: AND + 중첩 OR 필터가 SQL 조건으로 빌드된다", () => {
+        const table = pgTable("tc2_test", {
+            id: serial("id").primaryKey(),
+            category: text("category"),
+            qty: serial("qty"),
+            flag: text("flag"),
+        });
+
+        const result = parseFilterNode({
+            AND: [
+                { category: "A" },
+                { OR: [
+                    { qty: { op: "gte", value: 10 } },
+                    { flag: true },
+                ] },
+            ],
+        }, table);
+
+        expect(result).toBeDefined();
+    });
+
+    it("TC2: 단순 OR 배열도 파싱된다", () => {
+        const table = pgTable("tc2b_test", {
+            id: serial("id").primaryKey(),
+            title: text("title"),
+            description: text("description"),
+        });
+
+        const result = parseFilterNode({
+            OR: [
+                { title: { op: "ilike", value: "%AI%" } },
+                { description: { op: "ilike", value: "%데이터%" } },
+            ],
+        }, table);
+
+        expect(result).toBeDefined();
+    });
+
+    // TC3: 보안 방어 — allowedFilters 위반
+    it("TC3: allowedFilters에 없는 필드는 완전 묵살 (직접 접근)", () => {
+        const table = pgTable("tc3_test", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            title: text("title"),
+            passwordHash: text("password_hash"),
+        });
+
+        // password_hash 직접 접근 → 묵살
+        const r1 = parseFilterNode(
+            { passwordHash: { op: "eq", value: "xxx" } },
+            table,
+            ["status", "title"],
+        );
+        expect(r1).toBeUndefined(); // 모든 조건 제거됨
+    });
+
+    it("TC3: OR 틈새 우회 시도 시 미허용 필드만 묵살, 허용 필드는 유지", () => {
+        const table = pgTable("tc3b_test", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            isAdmin: text("is_admin"),
+        });
+
+        const r = parseFilterNode(
+            { OR: [{ status: "public" }, { isAdmin: true }] },
+            table,
+            ["status"],
+        );
+        // status는 허용 → OR 조건 살아있음
+        expect(r).toBeDefined();
+    });
+
+    it("TC3: 모든 필드가 미허용이면 undefined 반환", () => {
+        const table = pgTable("tc3c_test", {
+            id: serial("id").primaryKey(),
+            secret: text("secret"),
+        });
+
+        const r = parseFilterNode(
+            { OR: [{ secret: "hi" }] },
+            table,
+            ["status"],
+        );
+        expect(r).toBeUndefined();
+    });
+
+    // TC4: 악의적 페이로드 구조 방어
+    it("TC4: OR에 비배열 전달 시 무시, 크래시 없음", () => {
+        const table = pgTable("tc4_test", {
+            id: serial("id").primaryKey(),
+            age: serial("age"),
+        });
+
+        expect(parseFilterNode({ OR: "not-an-array" as any }, table)).toBeUndefined();
+    });
+
+    it("TC4: 미지원 op 키워드(DROP TABLE 등) 묵살, 크래시 없음", () => {
+        const table = pgTable("tc4b_test", {
+            id: serial("id").primaryKey(),
+            age: serial("age"),
+        });
+
+        expect(parseFilterNode({ age: { op: "DROP TABLE", value: 1 } }, table)).toBeUndefined();
+    });
+
+    it("TC4: AND에 null/string/number 등 비객체 원소 묵살", () => {
+        const table = pgTable("tc4c_test", {
+            id: serial("id").primaryKey(),
+        });
+
+        expect(parseFilterNode({ AND: [null, "string", 42] as any }, table)).toBeUndefined();
+        expect(parseFilterNode({ AND: null as any }, table)).toBeUndefined();
+    });
+
+    it("TC4: 존재하지 않는 컬럼명 필터는 묵살", () => {
+        const table = pgTable("tc4d_test", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+        });
+
+        const r = parseFilterNode({ nonExistentCol: "value" }, table);
+        expect(r).toBeUndefined();
+    });
+
+    // TC5: IN / NIN 연산자 배열값 처리
+    it("TC5: in 연산자 — 정상 배열은 SQL 생성", () => {
+        const table = pgTable("tc5_test", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+        });
+
+        const r = parseFilterNode({ id: { op: "in", value: [1, 2, 3] } }, table);
+        expect(r).toBeDefined();
+    });
+
+    it("TC5: in 연산자 — 비배열은 묵살", () => {
+        const table = pgTable("tc5b_test", {
+            id: serial("id").primaryKey(),
+        });
+
+        const r = parseFilterNode({ id: { op: "in", value: "1" } }, table);
+        expect(r).toBeUndefined();
+    });
+
+    it("TC5: in 연산자 — 빈 배열은 묵살", () => {
+        const table = pgTable("tc5c_test", {
+            id: serial("id").primaryKey(),
+        });
+
+        const r = parseFilterNode({ id: { op: "in", value: [] } }, table);
+        expect(r).toBeUndefined();
+    });
+
+    it("TC5: nin 연산자 — 정상 배열은 SQL 생성", () => {
+        const table = pgTable("tc5d_test", {
+            id: serial("id").primaryKey(),
+        });
+
+        const r = parseFilterNode({ id: { op: "nin", value: [10, 20] } }, table);
+        expect(r).toBeDefined();
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 12. v3 Filter Engine — applyFilterOp 직접 테스트
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("v3 Filter Engine — applyFilterOp", () => {
+    const table = pgTable("op_test", {
+        id: serial("id").primaryKey(),
+        name: text("name"),
+        age: serial("age"),
+    });
+
+    it("eq 연산자가 SQL 조건을 반환한다", () => {
+        expect(applyFilterOp(table.name, "eq", "test")).toBeDefined();
+    });
+
+    it("ne 연산자가 SQL 조건을 반환한다", () => {
+        expect(applyFilterOp(table.name, "ne", "test")).toBeDefined();
+    });
+
+    it("gt/gte/lt/lte 비교 연산자가 SQL 조건을 반환한다", () => {
+        expect(applyFilterOp(table.age, "gt", 10)).toBeDefined();
+        expect(applyFilterOp(table.age, "gte", 18)).toBeDefined();
+        expect(applyFilterOp(table.age, "lt", 100)).toBeDefined();
+        expect(applyFilterOp(table.age, "lte", 65)).toBeDefined();
+    });
+
+    it("like/ilike 패턴 연산자가 SQL 조건을 반환한다", () => {
+        expect(applyFilterOp(table.name, "like", "%test%")).toBeDefined();
+        expect(applyFilterOp(table.name, "ilike", "%TEST%")).toBeDefined();
+    });
+
+    it("in 연산자 — 정상 배열은 SQL 반환", () => {
+        expect(applyFilterOp(table.id, "in", [1, 2, 3])).toBeDefined();
+    });
+
+    it("nin 연산자 — 빈 배열은 undefined 반환", () => {
+        expect(applyFilterOp(table.id, "nin", [])).toBeUndefined();
+    });
+
+    it("미지원 연산자는 undefined 반환", () => {
+        expect(applyFilterOp(table.id, "INVALID" as any, 1)).toBeUndefined();
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 13. v3 crud() handler 통합 테스트 — Advanced Filters
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("v3 crud() — advanced filters through handler", () => {
+    it("allowedFilters 미설정 시 필터가 무시된다 (Secure by Default)", async () => {
+        const openTable = pgTable("v3_open_filter", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        // allowedFilters 미설정 → 필터 전체 무시 (v2 호환, Secure by Default)
+        crud(openTable, { public: true });
+
+        const listDef = getQueryDef("v3_open_filter.list");
+        expect(listDef).toBeDefined();
+
+        const mockCtx = createListMockCtx([{ id: 1, status: "active" }]);
+        const result = await listDef!.handler(mockCtx, {
+            filters: { status: { op: "eq", value: "active" } },
+        });
+
+        // 필터가 무시되어도 에러 없이 정상 동작
+        expect(result).toHaveProperty("data");
+        expect(result).toHaveProperty("total");
+    });
+
+    it("allowedFilters 설정 시 v3 고급 필터가 동작한다", async () => {
+        const advTable = pgTable("v3_adv_filter", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(advTable, { public: true, allowedFilters: ["status"] });
+
+        const listDef = getQueryDef("v3_adv_filter.list");
+        const mockCtx = createListMockCtx([{ id: 1, status: "active" }]);
+        const result = await listDef!.handler(mockCtx, {
+            filters: { status: { op: "eq", value: "active" } },
+        });
+
+        expect(result).toHaveProperty("data");
+        expect(result).toHaveProperty("total");
+    });
+
+    it("복합 OR/AND 필터가 handler에서 에러 없이 실행된다", async () => {
+        const complexTable = pgTable("v3_complex", {
+            id: serial("id").primaryKey(),
+            title: text("title"),
+            status: text("status"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(complexTable, { public: true, allowedFilters: ["title", "status"] });
+
+        const listDef = getQueryDef("v3_complex.list");
+        const mockCtx = createListMockCtx([]);
+
+        const result = await listDef!.handler(mockCtx, {
+            filters: {
+                OR: [
+                    { title: { op: "ilike", value: "%AI%" } },
+                    { status: { op: "in", value: ["active", "archived"] } },
+                ],
+            },
+        });
+
+        expect(result).toHaveProperty("data");
+        expect(result.total).toBe(0);
+    });
+
+    it("악성 페이로드가 handler를 크래시시키지 않는다", async () => {
+        const safeTable = pgTable("v3_safe", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(safeTable, { public: true });
+
+        const listDef = getQueryDef("v3_safe.list");
+        const mockCtx = createListMockCtx([{ id: 1 }]);
+
+        // 다양한 악성 페이로드 — 모두 에러 없이 실행
+        const payloads = [
+            { filters: { OR: "not-array" } },
+            { filters: { AND: null } },
+            { filters: { name: { op: "EVIL_OP", value: 1 } } },
+            { filters: { OR: [null, undefined, 42, "bad"] } },
+            { filters: {} },
+        ];
+
+        for (const payload of payloads) {
+            const result = await listDef!.handler(mockCtx, payload);
+            expect(result).toHaveProperty("data");
+            expect(result).toHaveProperty("total");
+        }
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 14. v3 보안 강화 — 재귀 깊이 제한 + like/ilike 타입 검증
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("v3 보안 강화 — 재귀 깊이 제한", () => {
+    it("MAX_FILTER_DEPTH(5) 초과 시 조건 묵살", () => {
+        const table = pgTable("depth_test", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+        });
+
+        // 깊이 6단계 중첩 — MAX_FILTER_DEPTH=5 초과
+        const deepFilter = {
+            OR: [{ AND: [{ OR: [{ AND: [{ OR: [{ AND: [{ name: "deep" }] }] }] }] }] }],
+        };
+
+        const result = parseFilterNode(deepFilter, table);
+        // 깊이 초과된 부분이 묵살되어 결과가 undefined이거나 부분 조건만 남음
+        // 중요한 것은 스택 오버플로 없이 정상 반환
+        expect(() => parseFilterNode(deepFilter, table)).not.toThrow();
+    });
+
+    it("MAX_FILTER_DEPTH 이내의 중첩은 정상 동작", () => {
+        const table = pgTable("depth_ok_test", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+            status: text("status"),
+        });
+
+        // 깊이 3단계 — 정상 범위
+        const normalFilter = {
+            OR: [
+                { AND: [{ OR: [{ name: "test" }] }] },
+                { status: "active" },
+            ],
+        };
+
+        const result = parseFilterNode(normalFilter, table);
+        expect(result).toBeDefined();
+    });
+
+    it("극단적 깊이(100단계)에서도 크래시 없음", () => {
+        const table = pgTable("depth_extreme_test", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+        });
+
+        // 100단계 중첩 생성
+        let filter: any = { name: "leaf" };
+        for (let i = 0; i < 100; i++) {
+            filter = i % 2 === 0 ? { OR: [filter] } : { AND: [filter] };
+        }
+
+        expect(() => parseFilterNode(filter, table)).not.toThrow();
+        // 깊이 초과로 조건 묵살 → undefined
+        const result = parseFilterNode(filter, table);
+        expect(result).toBeUndefined();
+    });
+});
+
+describe("v3 보안 강화 — like/ilike 타입 검증", () => {
+    const table = pgTable("like_type_test", {
+        id: serial("id").primaryKey(),
+        name: text("name"),
+    });
+
+    it("like에 문자열이 아닌 값 전달 시 undefined 반환", () => {
+        expect(applyFilterOp(table.name, "like", 12345)).toBeUndefined();
+        expect(applyFilterOp(table.name, "like", null)).toBeUndefined();
+        expect(applyFilterOp(table.name, "like", { evil: true })).toBeUndefined();
+    });
+
+    it("ilike에 문자열이 아닌 값 전달 시 undefined 반환", () => {
+        expect(applyFilterOp(table.name, "ilike", 99)).toBeUndefined();
+        expect(applyFilterOp(table.name, "ilike", ["array"])).toBeUndefined();
+    });
+
+    it("like/ilike에 정상 문자열 전달 시 SQL 반환", () => {
+        expect(applyFilterOp(table.name, "like", "%test%")).toBeDefined();
+        expect(applyFilterOp(table.name, "ilike", "%TEST%")).toBeDefined();
+    });
+});

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