@gencow/core 0.1.26 → 0.1.28

package/src/__tests__/reactive.test.ts

@@ -1,479 +0,0 @@
-/**
- * packages/core/src/__tests__/reactive.test.ts
- *
- * Tests for ctx.realtime.emit() push model and refresh() API.
- *
- * Run: bun test packages/core/src/__tests__/reactive.test.ts
- */
-
-import { describe, it, expect, mock, beforeEach } from "bun:test";
-import { buildRealtimeCtx, subscribe, deregisterClient, registerClient } from "../reactive.js";
-import type { GencowCtx } from "../reactive.js";
-
-// ─── Mock WebSocket (Bun-style WSContext) ────────────────────────────────────
-
-function makeMockWs() {
-  const sent: string[] = [];
-  return {
-    send: (msg: string) => sent.push(msg),
-    readyState: 1,
-    _sent: sent,
-  } as any;
-}
-
-// ─── buildRealtimeCtx ────────────────────────────────────────────────────────
-
-describe("buildRealtimeCtx()", () => {
-  it("각 mutation 호출마다 독립적인 인스턴스를 반환한다", () => {
-    const a = buildRealtimeCtx();
-    const b = buildRealtimeCtx();
-    expect(a).not.toBe(b);
-  });
-
-  it("emit() 호출 시 해당 queryKey 구독자에게 query:updated 메시지를 push한다", async () => {
-    const ws = makeMockWs();
-    subscribe("test.list", ws);
-
-    const rt = buildRealtimeCtx();
-    rt.emit("test.list", [{ id: 1, title: "Task A" }]);
-
-    // 50ms debounce 대기
-    await new Promise((r) => setTimeout(r, 60));
-
-    expect(ws._sent).toHaveLength(1);
-    const msg = JSON.parse(ws._sent[0]);
-    expect(msg.type).toBe("query:updated");
-    expect(msg.query).toBe("test.list");
-    expect(msg.data).toEqual([{ id: 1, title: "Task A" }]);
-
-    deregisterClient(ws);
-  });
-
-  it("50ms 내 동일 queryKey에 대한 연속 emit은 마지막 데이터만 push한다 (debounce)", async () => {
-    const ws = makeMockWs();
-    subscribe("test.debounce", ws);
-
-    const rt = buildRealtimeCtx();
-    rt.emit("test.debounce", [{ id: 1 }]); // 무시됨
-    rt.emit("test.debounce", [{ id: 2 }]); // 무시됨
-    rt.emit("test.debounce", [{ id: 3 }]); // 최종 emit
-
-    // 50ms debounce 대기
-    await new Promise((r) => setTimeout(r, 80));
-
-    expect(ws._sent).toHaveLength(1);
-    const msg = JSON.parse(ws._sent[0]);
-    expect(msg.data).toEqual([{ id: 3 }]); // 마지막 값만 전달
-
-    deregisterClient(ws);
-  });
-
-  it("서로 다른 queryKey emit은 각각 독립적으로 처리된다", async () => {
-    const ws = makeMockWs();
-    subscribe("alpha.list", ws);
-    subscribe("beta.list", ws);
-
-    const rt = buildRealtimeCtx();
-    rt.emit("alpha.list", [{ id: 10 }]);
-    rt.emit("beta.list", [{ id: 20 }]);
-
-    await new Promise((r) => setTimeout(r, 80));
-
-    expect(ws._sent).toHaveLength(2);
-    const queries = ws._sent.map((s: string) => JSON.parse(s).query);
-    expect(queries).toContain("alpha.list");
-    expect(queries).toContain("beta.list");
-
-    deregisterClient(ws);
-  });
-
-  it("구독자가 없으면 아무것도 전송하지 않는다", async () => {
-    const rt = buildRealtimeCtx();
-    rt.emit("no.subscribers", [{ id: 99 }]);
-
-    await new Promise((r) => setTimeout(r, 80));
-    // no assertion needed — just must not throw
-  });
-});
-
-// ─── refresh() API ──────────────────────────────────────────────────────────
-
-describe("refresh() — 서버 쿼리 재실행 요청 큐", () => {
-  it("refresh()로 등록된 queryKey가 _pendingRefresh에 큐잉된다", () => {
-    const rt = buildRealtimeCtx();
-    rt.refresh("tasks.list");
-
-    expect((rt as any)._pendingRefresh).toContain("tasks.list");
-  });
-
-  it("동일 queryKey 중복 refresh는 한 번만 큐잉된다", () => {
-    const rt = buildRealtimeCtx();
-    rt.refresh("tasks.list");
-    rt.refresh("tasks.list");
-    rt.refresh("tasks.list");
-
-    const count = (rt as any)._pendingRefresh.filter((k: string) => k === "tasks.list").length;
-    expect(count).toBe(1);
-  });
-
-  it("서로 다른 queryKey는 각각 큐잉된다", () => {
-    const rt = buildRealtimeCtx();
-    rt.refresh("tasks.list");
-    rt.refresh("users.list");
-
-    expect((rt as any)._pendingRefresh).toContain("tasks.list");
-    expect((rt as any)._pendingRefresh).toContain("users.list");
-  });
-});
-
-// ─── emit()과 refresh() 병행 시나리오 ───────────────────────────────────────
-
-describe("emit()과 refresh() 병행", () => {
-  it("emit()은 query:updated를 구독자에게 즉시 push한다", async () => {
-    const wsSubscribed = makeMockWs();
-    subscribe("items.list", wsSubscribed);
-
-    const rt = buildRealtimeCtx();
-    rt.emit("items.list", [{ id: 1 }]);
-    await new Promise((r) => setTimeout(r, 80));
-
-    expect(wsSubscribed._sent.some((s: string) => JSON.parse(s).type === "query:updated")).toBe(true);
-
-    deregisterClient(wsSubscribed);
-  });
-
-  it("emit() 호출 후 _hasEmitted가 true로 설정된다", () => {
-    const rt = buildRealtimeCtx();
-    expect((rt as any)._hasEmitted).toBe(false);
-
-    const ws = makeMockWs();
-    subscribe("flag.test", ws);
-    rt.emit("flag.test", [{ id: 1 }]);
-
-    expect((rt as any)._hasEmitted).toBe(true);
-
-    deregisterClient(ws);
-  });
-});
-
-// ─── Secure by Default: public 플래그 테스트 ─────────────────────────────────
-
-import { query, mutation, getQueryDef, getRegisteredMutations } from "../reactive.js";
-
-describe("Secure by Default — public 플래그", () => {
-  it("query() 기본값은 isPublic === false (auth 필수)", () => {
-    const q = query("sectest.private", {
-      handler: async () => [],
-    });
-    expect(q.isPublic).toBe(false);
-  });
-
-  it("query({ public: true }) 시 isPublic === true", () => {
-    const q = query("sectest.public", {
-      public: true,
-      handler: async () => [],
-    });
-    expect(q.isPublic).toBe(true);
-  });
-
-  it("query() legacy handler 형식도 isPublic === false", () => {
-    const q = query("sectest.legacy", async () => []);
-    expect(q.isPublic).toBe(false);
-  });
-
-  it("getQueryDef()로 조회해도 isPublic 정보가 유지된다", () => {
-    query("sectest.lookup", { public: true, handler: async () => "ok" });
-    const def = getQueryDef("sectest.lookup");
-    expect(def).toBeDefined();
-    expect(def!.isPublic).toBe(true);
-  });
-
-  it("mutation() 기본값은 isPublic === false", () => {
-    const m = mutation({
-      name: "sectest.mut.private",
-      handler: async () => ({ ok: true }),
-    });
-    expect(m.isPublic).toBe(false);
-  });
-
-  it("mutation({ public: true }) 시 isPublic === true", () => {
-    const m = mutation({
-      name: "sectest.mut.public",
-      public: true,
-      handler: async () => ({ ok: true }),
-    });
-    expect(m.isPublic).toBe(true);
-  });
-
-  it("mutation() legacy array 형식도 isPublic === false", () => {
-    const m = mutation(["some.key"], async () => ({ ok: true }), "sectest.mut.legacy");
-    expect(m.isPublic).toBe(false);
-  });
-
-  it("getRegisteredMutations()에서 isPublic 정보가 노출된다", () => {
-    const all = getRegisteredMutations();
-    const pub = all.find((m) => m.name === "sectest.mut.public");
-    const priv = all.find((m) => m.name === "sectest.mut.private");
-    expect(pub?.isPublic).toBe(true);
-    expect(priv?.isPublic).toBe(false);
-  });
-});
-
-// ─── mutation("name", def) 새 시그니처 테스트 ────────────────────────────────
-
-describe("mutation(name, def) — query와 동일 패턴", () => {
-  it("mutation('name', { handler })로 등록하면 name이 올바르게 설정된다", () => {
-    const m = mutation("newsig.basic", {
-      handler: async () => ({ ok: true }),
-    });
-    expect(
-      (m as any).name ||
-        (getRegisteredMutations().find((x) => x.handler === (m as any).handler) as any)?.name,
-    ).toBeDefined();
-    const all = getRegisteredMutations();
-    const found = all.find((x) => x.name === "newsig.basic");
-    expect(found).toBeDefined();
-    expect(found!.isPublic).toBe(false);
-  });
-
-  it("mutation('name', { public: true })로 등록하면 isPublic === true", () => {
-    const m = mutation("newsig.public", {
-      public: true,
-      handler: async () => ({ ok: true }),
-    });
-    expect(m.isPublic).toBe(true);
-  });
-
-  it("invalidates 미지정 시 빈 배열이 기본값 (하위호환)", () => {
-    const m = mutation("newsig.noInvalidates", {
-      handler: async () => ({ ok: true }),
-    });
-    const all = getRegisteredMutations();
-    const found = all.find((x) => x.name === "newsig.noInvalidates");
-    // invalidates는 deprecated이지만 빈 배열로 유지 (하위호환)
-    expect(found).toBeDefined();
-  });
-
-  it("invalidates 지정해도 무시된다 (deprecated)", () => {
-    const m = mutation("newsig.withInvalidates", {
-      invalidates: ["tasks.list", "tasks.get"],
-      handler: async () => ({ ok: true }),
-    });
-    const all = getRegisteredMutations();
-    const found = all.find((x) => x.name === "newsig.withInvalidates");
-    // invalidates는 deprecated — 전달해도 런타임에서 무시됨
-    expect(found).toBeDefined();
-  });
-
-  it("기존 객체 스타일도 여전히 동작한다 (하위 호환)", () => {
-    const m = mutation({
-      name: "newsig.compat.object",
-      handler: async () => ({ ok: true }),
-    });
-    const all = getRegisteredMutations();
-    const found = all.find((x) => x.name === "newsig.compat.object");
-    expect(found).toBeDefined();
-  });
-
-  it("기존 배열 스타일도 여전히 동작한다 (하위 호환)", () => {
-    const m = mutation(["b.list"], async () => ({ ok: true }), "newsig.compat.array");
-    const all = getRegisteredMutations();
-    const found = all.find((x) => x.name === "newsig.compat.array");
-    expect(found).toBeDefined();
-  });
-
-  it("이름 미지정 시 console.warn이 호출된다", () => {
-    const warnSpy = mock(() => {});
-    const originalWarn = console.warn;
-    console.warn = warnSpy;
-
-    mutation(["c.list"], async () => ({ ok: true }));
-
-    expect(warnSpy).toHaveBeenCalled();
-    const warnMsg = warnSpy.mock.calls[0][0] as string;
-    expect(warnMsg).toContain("[gencow]");
-    expect(warnMsg).toContain("without explicit name");
-
-    console.warn = originalWarn;
-  });
-});
-
-// ─── _flushRefresh — buildCtxForRefresh 통합 테스트 ──────────────────────────
-
-describe("_flushRefresh() — query re-run via buildCtxForRefresh", () => {
-  it("buildCtxForRefresh 전달 시 query handler가 정상 ctx로 re-run된다", async () => {
-    // 테스트용 query 등록
-    const testQueryKey = "flush.test.rerun";
-    const handler = mock(async (ctx: any) => {
-      // ctx.db가 존재하는지 확인 (이전 버그: ctx = {} → crash)
-      if (!ctx.db) throw new Error("ctx.db is undefined!");
-      return [{ id: 1, count: ctx.db.mockValue }];
-    });
-
-    query(testQueryKey, { public: true, handler });
-
-    // buildCtxForRefresh 콜백 제공
-    const mockDb = { mockValue: 42 };
-    const rt = buildRealtimeCtx({
-      buildCtxForRefresh: () =>
-        ({
-          db: mockDb,
-          auth: {
-            getUserIdentity: () => null,
-            requireAuth: () => {
-              throw new Error();
-            },
-          },
-          realtime: { emit: () => {}, refresh: () => {} },
-        }) as any,
-    });
-
-    rt.refresh(testQueryKey);
-    await rt._flushRefresh();
-
-    // handler가 호출됐는지 확인
-    expect(handler).toHaveBeenCalledTimes(1);
-    // ctx.db가 올바르게 전달됐는지 확인
-    const callCtx = handler.mock.calls[0][0];
-    expect(callCtx.db).toBe(mockDb);
-  });
-
-  it("buildCtxForRefresh 미전달 시 ({} as ctx) 사용 + 경고 로그 출력", async () => {
-    const testQueryKey = "flush.test.noCallback";
-    const handler = mock(async (_ctx: any) => [{ id: 1 }]);
-    query(testQueryKey, { public: true, handler });
-
-    const warnSpy = mock(() => {});
-    const originalWarn = console.warn;
-    console.warn = warnSpy;
-
-    // buildCtxForRefresh 없이 생성
-    const rt = buildRealtimeCtx();
-    rt.refresh(testQueryKey);
-    await rt._flushRefresh();
-
-    // 경고 출력 확인
-    const warnCalls = warnSpy.mock.calls.map((c) => String(c[0]));
-    const hasWarning = warnCalls.some((msg) => msg.includes("buildCtxForRefresh not provided"));
-    expect(hasWarning).toBe(true);
-
-    console.warn = originalWarn;
-  });
-
-  it("refresh 결과가 WS 구독자에게 query:updated로 push된다", async () => {
-    const testQueryKey = "flush.test.push";
-    const freshData = [{ id: 99, name: "Refreshed" }];
-    query(testQueryKey, {
-      public: true,
-      handler: async () => freshData,
-    });
-
-    const ws = makeMockWs();
-    subscribe(testQueryKey, ws);
-
-    const rt = buildRealtimeCtx({
-      buildCtxForRefresh: () =>
-        ({
-          db: {},
-          auth: {
-            getUserIdentity: () => null,
-            requireAuth: () => {
-              throw new Error();
-            },
-          },
-          realtime: { emit: () => {}, refresh: () => {} },
-        }) as any,
-    });
-
-    rt.refresh(testQueryKey);
-    await rt._flushRefresh();
-
-    // 50ms debounce 대기
-    await new Promise((r) => setTimeout(r, 80));
-
-    expect(ws._sent.length).toBeGreaterThanOrEqual(1);
-    const msg = JSON.parse(ws._sent[ws._sent.length - 1]);
-    expect(msg.type).toBe("query:updated");
-    expect(msg.query).toBe(testQueryKey);
-    expect(msg.data).toEqual(freshData);
-
-    deregisterClient(ws);
-  });
-
-  it("httpCallback 모드에서 refresh 결과가 callback으로 전달된다", async () => {
-    const testQueryKey = "flush.test.http";
-    const freshData = [{ id: 77, title: "HTTP Push" }];
-    query(testQueryKey, {
-      public: true,
-      handler: async () => freshData,
-    });
-
-    const httpCallback = mock((_event: any) => {});
-
-    const rt = buildRealtimeCtx({
-      httpCallback,
-      buildCtxForRefresh: () =>
-        ({
-          db: {},
-          auth: {
-            getUserIdentity: () => null,
-            requireAuth: () => {
-              throw new Error();
-            },
-          },
-          realtime: { emit: () => {}, refresh: () => {} },
-        }) as any,
-    });
-
-    rt.refresh(testQueryKey);
-    await rt._flushRefresh();
-
-    expect(httpCallback).toHaveBeenCalledTimes(1);
-    const event = httpCallback.mock.calls[0][0];
-    expect(event.type).toBe("emit");
-    expect(event.queryKey).toBe(testQueryKey);
-    expect(event.data).toEqual(freshData);
-  });
-
-  it("flush 후 _pendingRefresh가 비워진다", async () => {
-    const testQueryKey = "flush.test.clear";
-    query(testQueryKey, { public: true, handler: async () => [] });
-
-    const rt = buildRealtimeCtx({
-      buildCtxForRefresh: () =>
-        ({
-          db: {},
-          auth: {
-            getUserIdentity: () => null,
-            requireAuth: () => {
-              throw new Error();
-            },
-          },
-          realtime: { emit: () => {}, refresh: () => {} },
-        }) as any,
-    });
-
-    rt.refresh(testQueryKey);
-    expect(rt._pendingRefresh).toHaveLength(1);
-
-    await rt._flushRefresh();
-    expect(rt._pendingRefresh).toHaveLength(0);
-  });
-
-  it("미등록 queryKey refresh는 무시되고 경고 출력", async () => {
-    const warnSpy = mock(() => {});
-    const originalWarn = console.warn;
-    console.warn = warnSpy;
-
-    const rt = buildRealtimeCtx({
-      buildCtxForRefresh: () => ({}) as any,
-    });
-    rt.refresh("nonexistent.query.key.xyz");
-    await rt._flushRefresh();
-
-    const hasWarning = warnSpy.mock.calls.some((c) => String(c[0]).includes("query not found in registry"));
-    expect(hasWarning).toBe(true);
-
-    console.warn = originalWarn;
-  });
-});

package/src/__tests__/retry.test.ts

@@ -1,113 +0,0 @@
-import { describe, test, expect, mock } from "bun:test";
-import { withRetry } from "../retry.js";
-
-describe("withRetry", () => {
-  test("성공 시 즉시 반환", async () => {
-    const result = await withRetry(async () => "success");
-    expect(result).toBe("success");
-  });
-
-  test("첫 시도 실패 후 재시도 성공", async () => {
-    let attempt = 0;
-    const result = await withRetry(
-      async () => {
-        attempt++;
-        if (attempt < 2) throw new Error("fail");
-        return "recovered";
-      },
-      { initialBackoffMs: 10 },
-    );
-
-    expect(result).toBe("recovered");
-    expect(attempt).toBe(2);
-  });
-
-  test("maxAttempts 초과 시 마지막 에러 throw", async () => {
-    let attempt = 0;
-    try {
-      await withRetry(
-        async () => {
-          attempt++;
-          throw new Error(`fail-${attempt}`);
-        },
-        { maxAttempts: 3, initialBackoffMs: 10 },
-      );
-      expect(true).toBe(false); // 여기에 도달하면 안됨
-    } catch (err: unknown) {
-      expect((err as Error).message).toBe("fail-3");
-      expect(attempt).toBe(3);
-    }
-  });
-
-  test("shouldRetry가 false 반환 시 즉시 throw", async () => {
-    let attempt = 0;
-    try {
-      await withRetry(
-        async () => {
-          attempt++;
-          throw new Error("non-retryable");
-        },
-        {
-          maxAttempts: 5,
-          initialBackoffMs: 10,
-          shouldRetry: (err) => (err as Error).message !== "non-retryable",
-        },
-      );
-    } catch (err: unknown) {
-      expect((err as Error).message).toBe("non-retryable");
-      expect(attempt).toBe(1); // 재시도 없이 즉시 실패
-    }
-  });
-
-  test("onRetry 콜백 호출", async () => {
-    let attempt = 0;
-    const retries: number[] = [];
-
-    await withRetry(
-      async () => {
-        attempt++;
-        if (attempt < 3) throw new Error("fail");
-        return "ok";
-      },
-      {
-        initialBackoffMs: 10,
-        onRetry: (_err, attemptNum, _delay) => {
-          retries.push(attemptNum);
-        },
-      },
-    );
-
-    expect(retries).toEqual([1, 2]);
-  });
-
-  test("maxAttempts < 1이면 에러", async () => {
-    try {
-      await withRetry(async () => "ok", { maxAttempts: 0 });
-      expect(true).toBe(false);
-    } catch (err: unknown) {
-      expect((err as Error).message).toContain("maxAttempts must be >= 1");
-    }
-  });
-
-  test("maxAttempts = 1이면 재시도 없이 즉시 throw", async () => {
-    let attempt = 0;
-    try {
-      await withRetry(
-        async () => {
-          attempt++;
-          throw new Error("once");
-        },
-        { maxAttempts: 1 },
-      );
-    } catch (err: unknown) {
-      expect((err as Error).message).toBe("once");
-      expect(attempt).toBe(1);
-    }
-  });
-
-  test("비동기 함수 결과 타입 보존", async () => {
-    const result = await withRetry(async () => ({ id: 1, name: "test" }));
-    expect(result.id).toBe(1);
-    expect(result.name).toBe("test");
-  });
-});