@gencow/core 0.1.24 → 0.1.26

package/src/__tests__/crons.test.ts

@@ -1,81 +1,83 @@
 import { describe, test, expect } from "bun:test";
-import { cronJobs } from "../crons";
+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 — 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 — 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("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 — 특정 시각", () => {
+    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("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("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("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();
+    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("인라인 핸들러 지원", () => {
+    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("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");
-    });
+  test("interval — 옵션 없으면 에러", () => {
+    const crons = cronJobs();
+    expect(() => crons.interval("bad", {}, "bad")).toThrow("minutes, hours, 또는 seconds");
+  });
 });

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

@@ -24,41 +24,35 @@
 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";
+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(),
+  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(),
+  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(),
+  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"),
+  id: serial("id").primaryKey(),
+  key: text("key"),
+  value: text("value"),
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -66,46 +60,46 @@ const appSettings = pgTable("cg_app_settings", {
 // ═══════════════════════════════════════════════════════════════════════════════
 
 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");
-    });
+  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");
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -113,54 +107,54 @@ describe("crud() → 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 };
-            },
-        });
+  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" };
+      },
     });
 
-    it("crud 등록 + 수동 등록이 모두 getRegisteredQueries()에 포함된다", () => {
-        const queries = getRegisteredQueries();
+    mutation("cg_digests.generate", {
+      public: true,
+      handler: async (ctx) => {
+        return { success: true };
+      },
+    });
+  });
 
-        // crud 자동 등록
-        expect(queries).toContain("cg_articles.list");
-        expect(queries).toContain("cg_articles.get");
+  it("crud 등록 + 수동 등록이 모두 getRegisteredQueries()에 포함된다", () => {
+    const queries = getRegisteredQueries();
 
-        // 수동 등록
-        expect(queries).toContain("cg_digests.latest");
-    });
+    // crud 자동 등록
+    expect(queries).toContain("cg_articles.list");
+    expect(queries).toContain("cg_articles.get");
 
-    it("crud 등록 + 수동 등록이 모두 getRegisteredMutations()에 포함된다", () => {
-        const mutations = getRegisteredMutations();
-        const names = mutations.map((m) => m.name);
+    // 수동 등록
+    expect(queries).toContain("cg_digests.latest");
+  });
 
-        // crud 자동 등록
-        expect(names).toContain("cg_articles.create");
-        expect(names).toContain("cg_articles.update");
-        expect(names).toContain("cg_articles.remove");
+  it("crud 등록 + 수동 등록이 모두 getRegisteredMutations()에 포함된다", () => {
+    const mutations = getRegisteredMutations();
+    const names = mutations.map((m) => m.name);
 
-        // 수동 등록
-        expect(names).toContain("cg_digests.generate");
-    });
+    // 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");
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -168,43 +162,43 @@ describe("crud() + 수동 query/mutation 혼용", () => {
 // ═══════════════════════════════════════════════════════════════════════════════
 
 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 필수
+  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"),
     });
 
-    it("public: true 테이블의 모든 엔드포인트가 isPublic === true", () => {
-        const listDef = getQueryDef("cg_public_data.list");
-        const getDef = getQueryDef("cg_public_data.get");
+    crud(publicTable, { public: true });
+    crud(privateTable); // default: auth 필수
+  });
 
-        expect(listDef!.isPublic).toBe(true);
-        expect(getDef!.isPublic).toBe(true);
+  it("public: true 테이블의 모든 엔드포인트가 isPublic === true", () => {
+    const listDef = getQueryDef("cg_public_data.list");
+    const getDef = getQueryDef("cg_public_data.get");
 
-        const mutations = getRegisteredMutations();
-        const createDef = mutations.find((m) => m.name === "cg_public_data.create");
-        expect(createDef!.isPublic).toBe(true);
-    });
+    expect(listDef!.isPublic).toBe(true);
+    expect(getDef!.isPublic).toBe(true);
 
-    it("기본(private) 테이블의 모든 엔드포인트가 isPublic === false", () => {
-        const listDef = getQueryDef("cg_private_data.list");
-        const getDef = getQueryDef("cg_private_data.get");
+    const mutations = getRegisteredMutations();
+    const createDef = mutations.find((m) => m.name === "cg_public_data.create");
+    expect(createDef!.isPublic).toBe(true);
+  });
 
-        expect(listDef!.isPublic).toBe(false);
-        expect(getDef!.isPublic).toBe(false);
+  it("기본(private) 테이블의 모든 엔드포인트가 isPublic === false", () => {
+    const listDef = getQueryDef("cg_private_data.list");
+    const getDef = getQueryDef("cg_private_data.get");
 
-        const mutations = getRegisteredMutations();
-        const createDef = mutations.find((m) => m.name === "cg_private_data.create");
-        expect(createDef!.isPublic).toBe(false);
-    });
+    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);
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -212,41 +206,41 @@ describe("crud() isPublic 상태 — codegen auth 분기 정확성", () => {
 // ═══════════════════════════════════════════════════════════════════════════════
 
 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);
-    });
+  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);
+  });
 });