@gencow/core 0.1.12 → 0.1.13

package/src/__tests__/crud.test.ts

@@ -0,0 +1,527 @@
+/**
+ * packages/core/src/__tests__/crud.test.ts
+ *
+ * crud() v2 Zero-Boilerplate API Factory — 유닛 테스트
+ *
+ * 검증 항목:
+ *   1. 팩토리가 query/mutation을 글로벌 레지스트리에 자동 등록하는지
+ *   2. Secure by Default: 기본 auth 필수, public 옵션 동작
+ *   3. 반환 객체 구조: { list, get, create, update, remove }
+ *   4. 테이블명 기반 key 생성 (prefix 오버라이드)
+ *   5. options 기본값 (defaultLimit, maxLimit, realtime)
+ *   6. UUID id 자동 감지 (text PK → v.string())
+ *   7. list 반환값: { data: T[], total: number }
+ *   8. allowedFilters 화이트리스트 동작
+ *
+ * Run: bun test packages/core/src/__tests__/crud.test.ts
+ */
+
+import { describe, it, expect, beforeAll } from "bun:test";
+import { getRegisteredQueries, getRegisteredMutations, getQueryDef } from "../reactive";
+
+// ─── Mock PgTable ────────────────────────────────────────────────────────────
+// 실제 Drizzle pgTable을 사용 — getTableName() 등 Drizzle 공식 API 호환 보장
+
+import { pgTable, serial, text, timestamp } from "drizzle-orm/pg-core";
+
+// ─── crud import ───────────────────────────────────────────────────────
+
+import { crud } from "../crud";
+
+// ─── 테스트 테이블 정의 ────────────────────────────────────────────────────
+
+const tasks = pgTable("tasks", {
+    id: serial("id").primaryKey(),
+    title: text("title").notNull(),
+    description: text("description"),
+    userId: text("user_id"),
+    createdAt: timestamp("created_at").defaultNow(),
+    updatedAt: timestamp("updated_at").defaultNow(),
+});
+
+const articles = pgTable("articles", {
+    id: serial("id").primaryKey(),
+    title: text("title"),
+    createdAt: timestamp("created_at").defaultNow(),
+});
+
+const items = pgTable("items", {
+    id: serial("id").primaryKey(),
+    name: text("name"),
+});
+
+// ─── Mock 유틸 ─────────────────────────────────────────────────────────
+
+/**
+ * list handler가 parallel로 SELECT + COUNT를 실행하므로,
+ * select()가 두 가지 호출 패턴을 지원해야 함:
+ *   1. select()           → data query chain
+ *   2. select({count: _}) → count query chain
+ */
+function createListMockCtx(mockData: any[], opts?: { authCalled?: { value: boolean } }) {
+    // data select chain
+    const dataChain = {
+        from: () => dataChain,
+        where: () => dataChain,
+        orderBy: () => dataChain,
+        limit: () => dataChain,
+        offset: () => Promise.resolve(mockData),
+    };
+    // count select chain
+    const countChain = {
+        from: () => countChain,
+        where: () => Promise.resolve([{ count: mockData.length }]),
+    };
+
+    return {
+        auth: {
+            requireAuth: () => {
+                if (opts?.authCalled) opts.authCalled.value = true;
+                return { user: { id: "user-1" } };
+            },
+            getSession: () => null,
+        },
+        db: {
+            select: (selectArg?: any) => {
+                // select({count: ...}) — count query
+                if (selectArg && typeof selectArg === "object" && "count" in selectArg) {
+                    return countChain;
+                }
+                // select() — data query
+                return dataChain;
+            },
+        },
+    };
+}
+
+/**
+ * mutation handler 실행용 mock context.
+ * insert/update/delete + realtime emit + fetchListWithTotal(select+count) 지원.
+ */
+function createMutationMockCtx(opts: {
+    listData?: any[];
+    insertResult?: any;
+    authUser?: any;
+}) {
+    const listData = opts.listData ?? [];
+    const insertResult = opts.insertResult;
+    const emitted: { key: string; data: any }[] = [];
+    let capturedValues: any = null;
+
+    // select chain: data + count 양쪽 지원
+    const selectDataChain = {
+        from: () => selectDataChain,
+        where: () => selectDataChain,
+        orderBy: () => Promise.resolve(listData),
+    };
+    const selectCountChain = {
+        from: () => selectCountChain,
+        where: () => Promise.resolve([{ count: listData.length }]),
+    };
+
+    const mockCtx = {
+        auth: {
+            requireAuth: () => opts.authUser ?? { id: "user-1", email: "test@example.com" },
+        },
+        db: {
+            select: (selectArg?: any) => {
+                if (selectArg && typeof selectArg === "object" && "count" in selectArg) {
+                    return selectCountChain;
+                }
+                return selectDataChain;
+            },
+            insert: () => ({
+                values: (v: any) => { capturedValues = v; return { returning: () => Promise.resolve([insertResult]) }; },
+            }),
+            update: () => ({
+                set: () => ({ where: () => ({ returning: () => Promise.resolve([insertResult]) }) }),
+            }),
+            delete: () => ({
+                where: () => Promise.resolve(),
+            }),
+        },
+        realtime: {
+            emit: (key: string, data: any) => emitted.push({ key, data }),
+        },
+    };
+
+    return { mockCtx, emitted, getCapturedValues: () => capturedValues };
+}
+
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 1. 기본 동작: 팩토리 반환값 + 레지스트리 등록
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — 기본 동작", () => {
+    let result: ReturnType<typeof crud>;
+
+    beforeAll(() => {
+        result = crud(tasks);
+    });
+
+    it("{ list, get, create, update, remove } 5개 프로퍼티를 반환한다", () => {
+        expect(result).toHaveProperty("list");
+        expect(result).toHaveProperty("get");
+        expect(result).toHaveProperty("create");
+        expect(result).toHaveProperty("update");
+        expect(result).toHaveProperty("remove");
+        expect(Object.keys(result)).toHaveLength(5);
+    });
+
+    it("query/mutation 각각 레지스트리에 등록된다", () => {
+        const queries = getRegisteredQueries();
+        const mutations = getRegisteredMutations();
+
+        // query: tasks.list, tasks.get
+        expect(queries).toContain("tasks.list");
+        expect(queries).toContain("tasks.get");
+
+        // mutation: tasks.create, tasks.update, tasks.remove
+        const mutationNames = mutations.map((m: any) => m.name);
+        expect(mutationNames).toContain("tasks.create");
+        expect(mutationNames).toContain("tasks.update");
+        expect(mutationNames).toContain("tasks.remove");
+    });
+
+    it("등록된 query/mutation은 핸들러를 가지고 있다", () => {
+        const listDef = getQueryDef("tasks.list");
+        expect(listDef).toBeDefined();
+        expect(typeof listDef!.handler).toBe("function");
+
+        const getDef = getQueryDef("tasks.get");
+        expect(getDef).toBeDefined();
+        expect(typeof getDef!.handler).toBe("function");
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 2. Secure by Default — 인증 기본 활성화
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — Secure by Default", () => {
+    it("기본 호출 시 모든 query/mutation이 isPublic === false (auth 필수)", () => {
+        const result = crud(articles);
+
+        const listDef = getQueryDef("articles.list");
+        const getDef = getQueryDef("articles.get");
+
+        expect(listDef!.isPublic).toBe(false);
+        expect(getDef!.isPublic).toBe(false);
+
+        const mutations = getRegisteredMutations();
+        const createDef = mutations.find((m: any) => m.name === "articles.create");
+        const updateDef = mutations.find((m: any) => m.name === "articles.update");
+        const removeDef = mutations.find((m: any) => m.name === "articles.remove");
+
+        expect(createDef!.isPublic).toBe(false);
+        expect(updateDef!.isPublic).toBe(false);
+        expect(removeDef!.isPublic).toBe(false);
+    });
+
+    it("{ public: true } 옵션 시 모든 엔드포인트가 isPublic === true", () => {
+        const result = crud(items, { public: true });
+
+        const listDef = getQueryDef("items.list");
+        const getDef = getQueryDef("items.get");
+
+        expect(listDef!.isPublic).toBe(true);
+        expect(getDef!.isPublic).toBe(true);
+
+        const mutations = getRegisteredMutations();
+        const createDef = mutations.find((m: any) => m.name === "items.create");
+        expect(createDef!.isPublic).toBe(true);
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 3. prefix 오버라이드
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — prefix 오버라이드", () => {
+    it("prefix 옵션으로 키 네임스페이스를 변경할 수 있다", () => {
+        const customTable = pgTable("my_items", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+        });
+
+        crud(customTable, { prefix: "products", public: true });
+
+        const listDef = getQueryDef("products.list");
+        const getDef = getQueryDef("products.get");
+
+        expect(listDef).toBeDefined();
+        expect(getDef).toBeDefined();
+
+        const mutations = getRegisteredMutations();
+        expect(mutations.find((m: any) => m.name === "products.create")).toBeDefined();
+        expect(mutations.find((m: any) => m.name === "products.update")).toBeDefined();
+        expect(mutations.find((m: any) => m.name === "products.remove")).toBeDefined();
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 4. id 컬럼 필수 체크
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — 검증", () => {
+    it("id 컬럼이 없는 테이블은 에러를 던진다", () => {
+        // id 컬럼이 없는 실제 Drizzle 테이블
+        const badTable = pgTable("bad", {
+            name: text("name"),
+        });
+
+        expect(() => crud(badTable)).toThrow("[crud]");
+        expect(() => crud(badTable)).toThrow("must have an 'id' column");
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 5. 핸들러 실행 — list ({ data, total } 반환 검증)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — list handler 실행", () => {
+    it("list handler가 { data: T[], total: number } 형태로 반환한다", async () => {
+        const testTable = pgTable("handler_test", {
+            id: serial("id").primaryKey(),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(testTable, { public: true });
+
+        const listDef = getQueryDef("handler_test.list");
+        expect(listDef).toBeDefined();
+
+        const mockData = [{ id: 1 }, { id: 2 }];
+        const mockCtx = createListMockCtx(mockData);
+
+        const result = await listDef!.handler(mockCtx, {});
+
+        // { data, total } 형태 검증
+        expect(result).toHaveProperty("data");
+        expect(result).toHaveProperty("total");
+        expect(result.data).toEqual(mockData);
+        expect(result.total).toBe(2);
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 6. 핸들러 실행 — create (auth + userId 자동 주입 + realtime { data, total })
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — create handler 실행", () => {
+    it("인증된 사용자의 create가 userId 자동 주입 + { data, total } realtime emit", async () => {
+        const testTable = pgTable("create_test", {
+            id: serial("id").primaryKey(),
+            title: text("title"),
+            userId: text("user_id"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(testTable);
+
+        const mutations = getRegisteredMutations();
+        const createDef = mutations.find((m: any) => m.name === "create_test.create");
+        expect(createDef).toBeDefined();
+
+        const insertedData = { id: 42, title: "New Task", userId: "user-1" };
+        const { mockCtx, emitted, getCapturedValues } = createMutationMockCtx({
+            listData: [insertedData],
+            insertResult: insertedData,
+        });
+
+        const result = await createDef!.handler(mockCtx, { title: "New Task" });
+        expect(result).toEqual(insertedData);
+
+        // userId 자동 주입 확인
+        expect(getCapturedValues().userId).toBe("user-1");
+
+        // realtime emit — { data, total } 형태 확인
+        expect(emitted.length).toBeGreaterThanOrEqual(1);
+        expect(emitted[0].key).toBe("create_test.list");
+        expect(emitted[0].data).toHaveProperty("data");
+        expect(emitted[0].data).toHaveProperty("total");
+        expect(emitted[0].data.total).toBe(1);
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 7. 핸들러 실행 — remove (realtime { data, total })
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — remove handler 실행", () => {
+    it("remove가 ctx.db.delete().where() 호출 후 { data, total } realtime emit 한다", async () => {
+        const testTable = pgTable("remove_test", {
+            id: serial("id").primaryKey(),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(testTable);
+
+        const mutations = getRegisteredMutations();
+        const removeDef = mutations.find((m: any) => m.name === "remove_test.remove");
+        expect(removeDef).toBeDefined();
+
+        const { mockCtx, emitted } = createMutationMockCtx({
+            listData: [],  // 삭제 후 빈 리스트
+        });
+
+        const result = await removeDef!.handler(mockCtx, { id: 99 });
+        expect(result).toEqual({ success: true });
+
+        // realtime emit — { data, total } 형태
+        expect(emitted.length).toBeGreaterThanOrEqual(1);
+        expect(emitted[0].key).toBe("remove_test.list");
+        expect(emitted[0].data).toHaveProperty("data");
+        expect(emitted[0].data).toHaveProperty("total");
+        expect(emitted[0].data.total).toBe(0);
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 8. public: true — auth skip 확인
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — public 모드 auth skip", () => {
+    it("public: true 시 requireAuth를 호출하지 않는다", async () => {
+        const testTable = pgTable("pub_test", {
+            id: serial("id").primaryKey(),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(testTable, { public: true });
+
+        const listDef = getQueryDef("pub_test.list");
+        expect(listDef).toBeDefined();
+
+        const authCalled = { value: false };
+        const mockCtx = createListMockCtx([{ id: 1 }], { authCalled });
+
+        // public 모드에서는 requireAuth를 호출하면 안됨 → 별도 mock
+        mockCtx.auth.requireAuth = () => { authCalled.value = true; throw new Error("should not be called"); };
+
+        const result = await listDef!.handler(mockCtx, {});
+        expect(authCalled.value).toBe(false);
+        expect(result.data).toEqual([{ id: 1 }]);
+        expect(result.total).toBe(1);
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 9. UUID id 자동 감지
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — UUID id 자동 감지", () => {
+    it("text PK 테이블에서 get args에 string id validator를 사용한다", () => {
+        const uuidTable = pgTable("uuid_test", {
+            id: text("id").primaryKey(),  // UUID string PK
+            name: text("name"),
+        });
+
+        crud(uuidTable, { public: true });
+
+        const getDef = getQueryDef("uuid_test.get");
+        expect(getDef).toBeDefined();
+        // argsSchema에 id가 존재 (string 타입)
+        expect(getDef!.argsSchema).toBeDefined();
+        expect(getDef!.argsSchema).toHaveProperty("id");
+    });
+
+    it("serial PK 테이블에서 get args에 number id validator를 사용한다", () => {
+        const serialTable = pgTable("serial_test", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+        });
+
+        crud(serialTable, { public: true });
+
+        const getDef = getQueryDef("serial_test.get");
+        expect(getDef).toBeDefined();
+        expect(getDef!.argsSchema).toBeDefined();
+        expect(getDef!.argsSchema).toHaveProperty("id");
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 10. allowedFilters — 화이트리스트 동작
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("crud() — allowedFilters", () => {
+    it("allowedFilters에 명시된 필드의 필터가 적용된다", async () => {
+        const filterTable = pgTable("filter_test", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            category: text("category"),
+            userId: text("user_id"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(filterTable, {
+            public: true,
+            allowedFilters: ["status", "category"],
+        });
+
+        const listDef = getQueryDef("filter_test.list");
+        expect(listDef).toBeDefined();
+
+        // allowedFilters를 사용하면 handler가 에러 없이 실행됨
+        const mockCtx = createListMockCtx([{ id: 1, status: "active" }]);
+        const result = await listDef!.handler(mockCtx, {
+            filters: { status: "active" },
+        });
+
+        expect(result).toHaveProperty("data");
+        expect(result).toHaveProperty("total");
+    });
+
+    it("allowedFilters에 없는 필드의 필터는 무시된다 (보안)", async () => {
+        const filterTable2 = pgTable("filter_test2", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            userId: text("user_id"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(filterTable2, {
+            public: true,
+            allowedFilters: ["status"],
+        });
+
+        const listDef = getQueryDef("filter_test2.list");
+        expect(listDef).toBeDefined();
+
+        // userId는 allowedFilters에 없으므로 무시되어야 함
+        const mockCtx = createListMockCtx([{ id: 1 }]);
+        const result = await listDef!.handler(mockCtx, {
+            filters: { userId: "hacker-attempt" },
+        });
+
+        // 에러 없이 정상 실행 (필터가 무시됨)
+        expect(result).toHaveProperty("data");
+        expect(result).toHaveProperty("total");
+    });
+
+    it("filters가 비어있으면 에러 없이 동작한다", async () => {
+        const filterTable3 = pgTable("filter_test3", {
+            id: serial("id").primaryKey(),
+            status: text("status"),
+            createdAt: timestamp("created_at").defaultNow(),
+        });
+
+        crud(filterTable3, {
+            public: true,
+            allowedFilters: ["status"],
+        });
+
+        const listDef = getQueryDef("filter_test3.list");
+        const mockCtx = createListMockCtx([{ id: 1 }]);
+
+        // filters 미전달
+        const result1 = await listDef!.handler(mockCtx, {});
+        expect(result1).toHaveProperty("data");
+
+        // filters 빈 객체
+        const result2 = await listDef!.handler(mockCtx, { filters: {} });
+        expect(result2).toHaveProperty("data");
+    });
+});

package/src/__tests__/scheduler-exec.test.ts

@@ -142,17 +142,17 @@ describe("Scheduler 실행 — registerAction + executeAction", () => {
         expect(result).toBe("Hello World");
     });
 
-    it("미등록 action executeAction → 에러를 throw한다", async () => {
+    it("미등록 action executeAction → throw 안 함, console.error 출력", async () => {
         const scheduler = createScheduler();
-        // 미등록 action은 에러를 throw해야 함
-        let threw = false;
-        try {
-            await scheduler.executeAction("nonexistent");
-        } catch (e) {
-            threw = true;
-            expect((e as Error).message).toContain("not registered");
-        }
-        expect(threw).toBe(true);
+        // 공개 API는 에러를 삼기고 console.error만 출력
+        const errors: string[] = [];
+        const origError = console.error;
+        console.error = (...args: any[]) => { errors.push(args.map(String).join(" ")); };
+
+        await scheduler.executeAction("nonexistent"); // throw하지 않음
+
+        console.error = origError;
+        expect(errors.some(e => e.includes("nonexistent"))).toBe(true);
     });
 
     it("action 에러 시 다른 action에 영향 없음", async () => {
@@ -166,14 +166,11 @@ describe("Scheduler 실행 — registerAction + executeAction", () => {
             secondRan = true;
         });
 
-        // 실패하는 action — 에러를 throw함
-        let threw = false;
-        try {
-            await scheduler.executeAction("failing");
-        } catch {
-            threw = true;
-        }
-        expect(threw).toBe(true);
+        // 실패하는 action — 공개 API는 throw하지 않음 (에러를 삼김)
+        const origError = console.error;
+        console.error = () => {}; // suppress expected error log
+        await scheduler.executeAction("failing"); // throw하지 않음
+        console.error = origError;
 
         // 정상 action은 여전히 동작
         await scheduler.executeAction("healthy");