@gencow/core 0.1.23 → 0.1.25

package/src/__tests__/reactive.test.ts

@@ -7,451 +7,473 @@
  */
 
 import { describe, it, expect, mock, beforeEach } from "bun:test";
-import { buildRealtimeCtx, subscribe, deregisterClient, registerClient } from "../reactive";
-import type { GencowCtx } from "../reactive";
+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;
+  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("각 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);
+  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" }]);
+    const rt = buildRealtimeCtx();
+    rt.emit("test.list", [{ id: 1, title: "Task A" }]);
 
-        // 50ms debounce 대기
-        await new Promise(r => setTimeout(r, 60));
+    // 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" }]);
+    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);
-    });
+    deregisterClient(ws);
+  });
 
-    it("50ms 내 동일 queryKey에 대한 연속 emit은 마지막 데이터만 push한다 (debounce)", async () => {
-        const ws = makeMockWs();
-        subscribe("test.debounce", 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
+    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));
+    // 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 }]);        // 마지막 값만 전달
+    expect(ws._sent).toHaveLength(1);
+    const msg = JSON.parse(ws._sent[0]);
+    expect(msg.data).toEqual([{ id: 3 }]); // 마지막 값만 전달
 
-        deregisterClient(ws);
-    });
+    deregisterClient(ws);
+  });
 
-    it("서로 다른 queryKey emit은 각각 독립적으로 처리된다", async () => {
-        const ws = makeMockWs();
-        subscribe("alpha.list", ws);
-        subscribe("beta.list", 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 }]);
+    const rt = buildRealtimeCtx();
+    rt.emit("alpha.list", [{ id: 10 }]);
+    rt.emit("beta.list", [{ id: 20 }]);
 
-        await new Promise(r => setTimeout(r, 80));
+    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");
+    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);
-    });
+    deregisterClient(ws);
+  });
 
-    it("구독자가 없으면 아무것도 전송하지 않는다", async () => {
-        const rt = buildRealtimeCtx();
-        rt.emit("no.subscribers", [{ id: 99 }]);
+  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
-    });
+    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");
-    });
+  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);
+  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));
+    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);
+    expect(wsSubscribed._sent.some((s: string) => JSON.parse(s).type === "query:updated")).toBe(true);
 
-        deregisterClient(wsSubscribed);
-    });
+    deregisterClient(wsSubscribed);
+  });
 
-    it("emit() 호출 후 _hasEmitted가 true로 설정된다", () => {
-        const rt = buildRealtimeCtx();
-        expect((rt as any)._hasEmitted).toBe(false);
+  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 }]);
+    const ws = makeMockWs();
+    subscribe("flag.test", ws);
+    rt.emit("flag.test", [{ id: 1 }]);
 
-        expect((rt as any)._hasEmitted).toBe(true);
+    expect((rt as any)._hasEmitted).toBe(true);
 
-        deregisterClient(ws);
-    });
+    deregisterClient(ws);
+  });
 });
 
 // ─── Secure by Default: public 플래그 테스트 ─────────────────────────────────
 
-import { query, mutation, getQueryDef, getRegisteredMutations } from "../reactive";
+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() 기본값은 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({ public: true }) 시 isPublic === true", () => {
+    const q = query("sectest.public", {
+      public: true,
+      handler: async () => [],
     });
-
-    it("query() legacy handler 형식도 isPublic === false", () => {
-        const q = query("sectest.legacy", async () => []);
-        expect(q.isPublic).toBe(false);
+    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 }),
     });
-
-    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);
+    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', { handler })로 등록하면 name이 올바르게 설정된다", () => {
+    const m = mutation("newsig.basic", {
+      handler: async () => ({ ok: true }),
     });
-
-    it("mutation('name', { public: true })로 등록하면 isPublic === true", () => {
-        const m = mutation("newsig.public", {
-            public: true,
-            handler: async () => ({ ok: true }),
-        });
-        expect(m.isPublic).toBe(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 미지정 시 빈 배열이 기본값 (하위호환)", () => {
+    const m = mutation("newsig.noInvalidates", {
+      handler: async () => ({ ok: true }),
     });
-
-    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();
+    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 }),
     });
-
-    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;
+    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,
+    });
 
-    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);
+    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,
     });
 
-    it("buildCtxForRefresh 미전달 시 ({} as ctx) 사용 + 경고 로그 출력", async () => {
-        const testQueryKey = "flush.test.noCallback";
-        const handler = mock(async (_ctx: any) => [{ id: 1 }]);
-        query(testQueryKey, { public: true, handler });
+    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();
 
-        const warnSpy = mock(() => {});
-        const originalWarn = console.warn;
-        console.warn = warnSpy;
+    // 50ms debounce 대기
+    await new Promise((r) => setTimeout(r, 80));
 
-        // buildCtxForRefresh 없이 생성
-        const rt = buildRealtimeCtx();
-        rt.refresh(testQueryKey);
-        await rt._flushRefresh();
+    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);
 
-        // 경고 출력 확인
-        const warnCalls = warnSpy.mock.calls.map(c => String(c[0]));
-        const hasWarning = warnCalls.some(msg =>
-            msg.includes("buildCtxForRefresh not provided")
-        );
-        expect(hasWarning).toBe(true);
+    deregisterClient(ws);
+  });
 
-        console.warn = originalWarn;
+  it("httpCallback 모드에서 refresh 결과가 callback으로 전달된다", async () => {
+    const testQueryKey = "flush.test.http";
+    const freshData = [{ id: 77, title: "HTTP Push" }];
+    query(testQueryKey, {
+      public: true,
+      handler: async () => freshData,
     });
 
-    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);
+    const httpCallback = mock((_event: any) => {});
+
+    const rt = buildRealtimeCtx({
+      httpCallback,
+      buildCtxForRefresh: () =>
+        ({
+          db: {},
+          auth: {
+            getUserIdentity: () => null,
+            requireAuth: () => {
+              throw new Error();
+            },
+          },
+          realtime: { emit: () => {}, refresh: () => {} },
+        }) as any,
     });
 
-    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);
+    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,
     });
 
-    it("flush 후 _pendingRefresh가 비워진다", async () => {
-        const testQueryKey = "flush.test.clear";
-        query(testQueryKey, { public: true, handler: async () => [] });
+    rt.refresh(testQueryKey);
+    expect(rt._pendingRefresh).toHaveLength(1);
 
-        const rt = buildRealtimeCtx({
-            buildCtxForRefresh: () => ({
-                db: {},
-                auth: { getUserIdentity: () => null, requireAuth: () => { throw new Error(); } },
-                realtime: { emit: () => {}, refresh: () => {} },
-            } as any),
-        });
+    await rt._flushRefresh();
+    expect(rt._pendingRefresh).toHaveLength(0);
+  });
 
-        rt.refresh(testQueryKey);
-        expect(rt._pendingRefresh).toHaveLength(1);
+  it("미등록 queryKey refresh는 무시되고 경고 출력", async () => {
+    const warnSpy = mock(() => {});
+    const originalWarn = console.warn;
+    console.warn = warnSpy;
 
-        await rt._flushRefresh();
-        expect(rt._pendingRefresh).toHaveLength(0);
+    const rt = buildRealtimeCtx({
+      buildCtxForRefresh: () => ({}) as any,
     });
+    rt.refresh("nonexistent.query.key.xyz");
+    await rt._flushRefresh();
 
-    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);
 
-        const hasWarning = warnSpy.mock.calls.some(c =>
-            String(c[0]).includes("query not found in registry")
-        );
-        expect(hasWarning).toBe(true);
-
-        console.warn = originalWarn;
-    });
+    console.warn = originalWarn;
+  });
 });