@gencow/core 0.1.0

package/src/__tests__/crons.test.ts

@@ -0,0 +1,81 @@
+import { describe, test, expect } from "bun:test";
+import { cronJobs } from "../crons";
+
+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 — 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("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("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("체이닝 지원", () => {
+        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("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");
+    });
+});

package/src/__tests__/load.test.ts

@@ -0,0 +1,394 @@
+/**
+ * packages/core/src/__tests__/load.test.ts
+ *
+ * Load / stress tests for ctx.realtime.emit() push model.
+ *
+ * Run: bun test packages/core/src/__tests__/load.test.ts
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+    buildRealtimeCtx,
+    invalidateQueries,
+    subscribe,
+    registerClient,
+    deregisterClient,
+} from "../reactive";
+import type { GencowCtx } from "../reactive";
+
+// ─── Mock WSContext ───────────────────────────────────────────────────────────
+
+function makeMockWs(id = 0) {
+    let sendCount = 0;
+    let lastPayloadBytes = 0;
+    return {
+        send: (msg: string) => {
+            sendCount++;
+            lastPayloadBytes = msg.length;
+        },
+        readyState: 1,
+        id,
+        get sendCount() { return sendCount; },
+        get lastPayloadBytes() { return lastPayloadBytes; },
+    } as any;
+}
+
+// 메시지 타입을 추적하는 WS (비교 테스트용)
+function makeTrackedWs(id = 0) {
+    type Msg = { type: string; hasData: boolean };
+    const received: Msg[] = [];
+    return {
+        send: (msg: string) => {
+            const parsed = JSON.parse(msg);
+            received.push({
+                type: parsed.type,
+                hasData: parsed.data !== undefined,
+            });
+        },
+        readyState: 1,
+        id,
+        get received() { return received; },
+        get sendCount() { return received.length; },
+    } as any;
+}
+
+const wait = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+function makeUniqueKey(prefix: string) {
+    return `${prefix}.${Math.random().toString(36).slice(2)}`;
+}
+
+// ─── 1. 다수 구독자 throughput ────────────────────────────────────────────────
+
+describe("[Load] 다수 구독자 emit 처리량", () => {
+    it("1,000명 구독자에게 emit이 150ms 이내에 완료된다", async () => {
+        const N = 1_000;
+        const key = makeUniqueKey("load1k");
+        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+        clients.forEach(ws => subscribe(key, ws));
+
+        const rt = buildRealtimeCtx();
+        const start = performance.now();
+        rt.emit(key, [{ id: 1, title: "Task 1" }]);
+        await wait(60);
+        const elapsed = performance.now() - start;
+
+        console.log(`[throughput]  1,000 subscribers → ${elapsed.toFixed(1)}ms`);
+        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
+        expect(elapsed).toBeLessThan(150);
+        clients.forEach(ws => deregisterClient(ws));
+    });
+
+    it("5,000명 구독자에게 emit이 300ms 이내에 완료된다", async () => {
+        const N = 5_000;
+        const key = makeUniqueKey("load5k");
+        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+        clients.forEach(ws => subscribe(key, ws));
+
+        const rt = buildRealtimeCtx();
+        const start = performance.now();
+        rt.emit(key, [{ id: 1 }]);
+        await wait(60);
+        const elapsed = performance.now() - start;
+
+        console.log(`[throughput]  5,000 subscribers → ${elapsed.toFixed(1)}ms`);
+        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
+        expect(elapsed).toBeLessThan(300);
+        clients.forEach(ws => deregisterClient(ws));
+    });
+
+    it("10,000명 구독자에게 emit이 500ms 이내에 완료된다", async () => {
+        const N = 10_000;
+        const key = makeUniqueKey("load10k");
+        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+        clients.forEach(ws => subscribe(key, ws));
+
+        const rt = buildRealtimeCtx();
+        const start = performance.now();
+        rt.emit(key, [{ id: 1 }]);
+        await wait(60);
+        const elapsed = performance.now() - start;
+
+        console.log(`[throughput] 10,000 subscribers → ${elapsed.toFixed(1)}ms`);
+        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
+        expect(elapsed).toBeLessThan(500);
+        clients.forEach(ws => deregisterClient(ws));
+    });
+
+    it("50,000명 구독자에게 emit이 2,000ms 이내에 완료된다", async () => {
+        const N = 50_000;
+        const key = makeUniqueKey("load50k");
+        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+        clients.forEach(ws => subscribe(key, ws));
+
+        const rt = buildRealtimeCtx();
+        const start = performance.now();
+        rt.emit(key, [{ id: 1 }]);
+        await wait(60);
+        const elapsed = performance.now() - start;
+
+        console.log(`[throughput] 50,000 subscribers → ${elapsed.toFixed(1)}ms`);
+        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
+        expect(elapsed).toBeLessThan(2_000);
+        clients.forEach(ws => deregisterClient(ws));
+    });
+
+    it("100,000명 구독자에게 emit이 5,000ms 이내에 완료된다", async () => {
+        const N = 100_000;
+        const key = makeUniqueKey("load100k");
+        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+        clients.forEach(ws => subscribe(key, ws));
+
+        const rt = buildRealtimeCtx();
+        const start = performance.now();
+        rt.emit(key, [{ id: 1 }]);
+        await wait(60);
+        const elapsed = performance.now() - start;
+
+        console.log(`[throughput]100,000 subscribers → ${elapsed.toFixed(1)}ms`);
+        expect(clients.filter(ws => ws.sendCount === 1).length).toBe(N);
+        expect(elapsed).toBeLessThan(5_000);
+        clients.forEach(ws => deregisterClient(ws));
+    });
+});
+
+// ─── 2. 동시 다수 queryKey emit 처리량 ─────────────────────────────────────
+
+describe("[Load] 동시 다수 queryKey emit", () => {
+    it("100개 queryKey × 100명 구독자 emit을 200ms 이내에 처리한다", async () => {
+        const KEYS = 100;
+        const SUBS_PER_KEY = 100;
+        const keyMap: { key: string; clients: any[] }[] = [];
+
+        for (let k = 0; k < KEYS; k++) {
+            const key = makeUniqueKey(`multi.${k}`);
+            const clients = Array.from({ length: SUBS_PER_KEY }, (_, i) => makeMockWs(k * 1000 + i));
+            clients.forEach(ws => subscribe(key, ws));
+            keyMap.push({ key, clients });
+        }
+
+        const rt = buildRealtimeCtx();
+        const start = performance.now();
+        for (const { key } of keyMap) {
+            rt.emit(key, [{ id: Math.random() }]);
+        }
+        await wait(80);
+        const elapsed = performance.now() - start;
+
+        console.log(`[multi-key] 100 keys × 100 subs → ${elapsed.toFixed(1)}ms`);
+
+        const totalReceived = keyMap.reduce(
+            (acc, { clients }) => acc + clients.filter(ws => ws.sendCount === 1).length,
+            0
+        );
+        expect(totalReceived).toBe(KEYS * SUBS_PER_KEY);
+        expect(elapsed).toBeLessThan(200);
+
+        keyMap.forEach(({ clients }) => clients.forEach(ws => deregisterClient(ws)));
+    });
+});
+
+// ─── 3. debounce 효율 ────────────────────────────────────────────────────────
+
+describe("[Load] 빠른 연속 emit debounce 효율", () => {
+    it("50ms 이내 100번 연속 emit은 단 1회만 전송된다", async () => {
+        const key = makeUniqueKey("debounce.stress");
+        const ws = makeMockWs();
+        subscribe(key, ws);
+
+        const rt = buildRealtimeCtx();
+        for (let i = 0; i < 100; i++) {
+            rt.emit(key, [{ id: i, title: `Task ${i}` }]);
+        }
+        await wait(80);
+
+        console.log(`[debounce] 100 rapid emits → ${ws.sendCount} actual sends`);
+        expect(ws.sendCount).toBe(1);
+
+        deregisterClient(ws);
+    });
+
+    it("debounce 효율: 1,000번 emit → 전송 횟수 감소율 99% 이상", async () => {
+        const key = makeUniqueKey("debounce.efficiency");
+        const ws = makeMockWs();
+        subscribe(key, ws);
+
+        const rt = buildRealtimeCtx();
+        const RAPID = 1_000;
+        const emitStart = performance.now();
+        for (let i = 0; i < RAPID; i++) {
+            rt.emit(key, Array.from({ length: 10 }, (_, j) => ({ id: j, value: i })));
+        }
+        const emitTime = performance.now() - emitStart;
+        await wait(80);
+
+        const reductionRate = ((RAPID - ws.sendCount) / RAPID) * 100;
+        console.log(`[debounce] emits: ${RAPID}, sends: ${ws.sendCount}, reduction: ${reductionRate.toFixed(1)}%, loop: ${emitTime.toFixed(1)}ms`);
+
+        expect(reductionRate).toBeGreaterThanOrEqual(99);
+        expect(ws.sendCount).toBe(1);
+        expect(emitTime).toBeLessThan(100);
+
+        deregisterClient(ws);
+    });
+});
+
+// ─── 4. connect/disconnect 반복 안정성 ─────────────────────────────────────
+
+describe("[Load] 클라이언트 connect/disconnect 안정성", () => {
+    it("10,000번 connect/disconnect 반복 후 메모리 안정적이다", () => {
+        const CYCLES = 10_000;
+        const key = makeUniqueKey("churn.list");
+        const before = process.memoryUsage().heapUsed;
+
+        for (let i = 0; i < CYCLES; i++) {
+            const ws = makeMockWs(i);
+            registerClient(ws);
+            subscribe(key, ws);
+            deregisterClient(ws);
+        }
+
+        const after = process.memoryUsage().heapUsed;
+        const diffMB = (after - before) / 1024 / 1024;
+        console.log(`[churn] 10k connect/disconnect → heap diff: ${diffMB.toFixed(2)}MB`);
+
+        expect(diffMB).toBeLessThan(50);
+    });
+
+    it("zombie ws(send throw)는 emit 후 자동 정리되고 이후 정상 클라이언트는 영향 없다", async () => {
+        const key = makeUniqueKey("dead.cleanup");
+        let throwCount = 0;
+
+        const zombieWs = {
+            send: () => { throwCount++; throw new Error("WebSocket closed"); },
+            readyState: 3,
+        } as any;
+        subscribe(key, zombieWs);
+
+        const rt = buildRealtimeCtx();
+        rt.emit(key, [{ id: 1 }]);
+        await wait(80);
+        expect(throwCount).toBe(1);
+
+        // zombie 정리 후 정상 클라이언트 추가
+        const normalWs = makeMockWs();
+        subscribe(key, normalWs);
+
+        const rt2 = buildRealtimeCtx();
+        rt2.emit(key, [{ id: 2 }]);
+        await wait(80);
+
+        expect(normalWs.sendCount).toBe(1);
+        deregisterClient(normalWs);
+    });
+});
+
+// ─── 5. 대용량 페이로드 성능 ─────────────────────────────────────────────────
+
+describe("[Load] 대용량 페이로드 emit 성능", () => {
+    it("10,000행 데이터셋을 100명 구독자에게 500ms 이내에 전송한다", async () => {
+        const N_ROWS = 10_000;
+        const N_SUBS = 100;
+        const key = makeUniqueKey("large.payload");
+
+        const largeDataset = Array.from({ length: N_ROWS }, (_, i) => ({
+            id: i,
+            title: `Task ${i}`,
+            description: `Description for task ${i} to simulate real content length`,
+            done: i % 2 === 0,
+            createdAt: new Date().toISOString(),
+            tags: ["alpha", "beta", "gamma"],
+        }));
+
+        const clients = Array.from({ length: N_SUBS }, (_, i) => makeMockWs(i));
+        clients.forEach(ws => subscribe(key, ws));
+
+        const rt = buildRealtimeCtx();
+        const start = performance.now();
+        rt.emit(key, largeDataset);
+        await wait(80);
+        const elapsed = performance.now() - start;
+
+        const payloadKB = clients[0]?.lastPayloadBytes / 1024;
+        console.log(`[large payload] ${N_ROWS} rows × ${N_SUBS} subs → ${elapsed.toFixed(1)}ms, payload: ${payloadKB.toFixed(1)}KB`);
+
+        const received = clients.filter(ws => ws.sendCount === 1).length;
+        expect(received).toBe(N_SUBS);
+        expect(elapsed).toBeLessThan(500);
+
+        clients.forEach(ws => deregisterClient(ws));
+    });
+});
+
+// ─── 6. invalidateQueries broadcast 확장성 ──────────────────────────────────
+
+describe("[Load] invalidateQueries broadcast 확장성", () => {
+    it("1,000개 connectedClients에 broadcast를 50ms 이내에 완료한다", async () => {
+        const N = 1_000;
+        const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
+        clients.forEach(ws => registerClient(ws));
+
+        const mockCtx = {} as GencowCtx;
+        const start = performance.now();
+        await invalidateQueries(["tasks.list", "tasks.get"], mockCtx);
+        const elapsed = performance.now() - start;
+
+        console.log(`[broadcast] 1,000 connectedClients → ${elapsed.toFixed(1)}ms`);
+
+        const received = clients.filter(ws => ws.sendCount === 1).length;
+        expect(received).toBe(N);
+        expect(elapsed).toBeLessThan(50);
+
+        clients.forEach(ws => deregisterClient(ws));
+    });
+});
+
+// ─── 7. push vs legacy 비교 ─────────────────────────────────────────────────
+
+describe("[Load] Push 방식 vs Legacy invalidateQueries 비교", () => {
+    it("emit(push)는 query:updated+data를, legacy는 invalidate 신호만 전달한다", async () => {
+        const N_SUBS = 500;
+        const keyPush = makeUniqueKey("compare.push");
+        const keyLegacy = makeUniqueKey("compare.legacy");
+
+        // push: 구독 클라이언트 (query:updated 수신 예상)
+        const pushClients = Array.from({ length: N_SUBS }, (_, i) => makeTrackedWs(i));
+        // legacy: connectedClients 전용 (invalidate broadcast 수신 예상)
+        const legacyClients = Array.from({ length: N_SUBS }, (_, i) => makeTrackedWs(i + N_SUBS));
+
+        pushClients.forEach(ws => subscribe(keyPush, ws));
+        legacyClients.forEach(ws => registerClient(ws)); // subscribe 안 함 → invalidate만 수신
+
+        const data = Array.from({ length: 100 }, (_, i) => ({ id: i, title: `T${i}` }));
+
+        // Push path: emit → 50ms debounce → query:updated 전송
+        const pushStart = performance.now();
+        buildRealtimeCtx().emit(keyPush, data);
+        await wait(80);
+        const pushElapsed = performance.now() - pushStart;
+
+        // Legacy path: invalidate broadcast 즉시 전송
+        const legacyStart = performance.now();
+        await invalidateQueries([keyLegacy], {} as GencowCtx);
+        const legacyElapsed = performance.now() - legacyStart;
+
+        const pushWithData = pushClients.filter(ws =>
+            ws.received.some((m: any) => m.type === "query:updated" && m.hasData)
+        ).length;
+
+        const legacyWithSignal = legacyClients.filter(ws =>
+            ws.received.some((m: any) => m.type === "invalidate")
+        ).length;
+
+        console.log(`[compare] Push  : ${pushElapsed.toFixed(1)}ms → ${pushWithData}/${N_SUBS} with data (query:updated)`);
+        console.log(`[compare] Legacy: ${legacyElapsed.toFixed(1)}ms → ${legacyWithSignal}/${N_SUBS} signal only (invalidate)`);
+
+        // 핵심 검증
+        expect(pushWithData).toBe(N_SUBS);       // 500/500이 data 포함 메시지 수신
+        expect(legacyWithSignal).toBe(N_SUBS);   // 500/500이 신호 수신
+        expect(legacyElapsed).toBeLessThan(pushElapsed); // legacy가 더 즉각적 (debounce 없음)
+
+        pushClients.forEach(ws => deregisterClient(ws));
+        legacyClients.forEach(ws => deregisterClient(ws));
+    });
+});