@gencow/core 0.1.17 → 0.1.19

package/src/__tests__/load.test.ts

@@ -9,7 +9,6 @@
 import { describe, it, expect } from "bun:test";
 import {
     buildRealtimeCtx,
-    invalidateQueries,
     subscribe,
     registerClient,
     deregisterClient,
@@ -320,44 +319,40 @@ describe("[Load] 대용량 페이로드 emit 성능", () => {
     });
 });
 
-// ─── 6. invalidateQueries broadcast 확장성 ──────────────────────────────────
+// ─── 6. emit broadcast 확장성 (컨넥튰드 클라이언트 기반) ─────────────────────────
 
-describe("[Load] invalidateQueries broadcast 확장성", () => {
-    it("1,000개 connectedClients에 broadcast를 50ms 이내에 완료한다", async () => {
+describe("[Load] emit broadcast 확장성", () => {
+    it("1,000개 구독자에게 emit이 50ms 이내에 완료된다", async () => {
         const N = 1_000;
+        const key = makeUniqueKey("broadcast1k");
         const clients = Array.from({ length: N }, (_, i) => makeMockWs(i));
-        clients.forEach(ws => registerClient(ws));
+        clients.forEach(ws => subscribe(key, ws));
 
-        const mockCtx = {} as GencowCtx;
         const start = performance.now();
-        await invalidateQueries(["tasks.list", "tasks.get"], mockCtx);
+        buildRealtimeCtx().emit(key, [{ id: 1 }, { id: 2 }]);
+        await wait(60);
         const elapsed = performance.now() - start;
 
-        console.log(`[broadcast] 1,000 connectedClients → ${elapsed.toFixed(1)}ms`);
+        console.log(`[broadcast] 1,000 subscribers → ${elapsed.toFixed(1)}ms`);
 
         const received = clients.filter(ws => ws.sendCount === 1).length;
         expect(received).toBe(N);
-        expect(elapsed).toBeLessThan(50);
+        expect(elapsed).toBeLessThan(100); // emit has 50ms debounce
 
         clients.forEach(ws => deregisterClient(ws));
     });
 });
 
-// ─── 7. push vs legacy 비교 ─────────────────────────────────────────────────
+// ─── 7. Push emit 포맷 검증 ───────────────────────────────────────────────
 
-describe("[Load] Push 방식 vs Legacy invalidateQueries 비교", () => {
-    it("emit(push)는 query:updated+data를, legacy는 invalidate 신호만 전달한다", async () => {
+describe("[Load] Push emit 포맷 검증", () => {
+    it("emit(push)은 query:updated+data를 실제 페이로드와 함께 전달한다", 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}` }));
 
@@ -367,28 +362,15 @@ describe("[Load] Push 방식 vs Legacy invalidateQueries 비교", () => {
         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)`);
+        console.log(`[push] ${pushElapsed.toFixed(1)}ms → ${pushWithData}/${N_SUBS} with data (query:updated)`);
 
         // 핵심 검증
         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));
     });
 });

package/src/__tests__/reactive.test.ts

@@ -1,13 +1,13 @@
 /**
  * packages/core/src/__tests__/reactive.test.ts
  *
- * Tests for ctx.realtime.emit() push model and invalidateQueries() simplification.
+ * 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, invalidateQueries, subscribe, deregisterClient, registerClient } from "../reactive";
+import { buildRealtimeCtx, subscribe, deregisterClient, registerClient } from "../reactive";
 import type { GencowCtx } from "../reactive";
 
 // ─── Mock WebSocket (Bun-style WSContext) ────────────────────────────────────
@@ -96,78 +96,63 @@ describe("buildRealtimeCtx()", () => {
     });
 });
 
-// ─── invalidateQueries (simplified) ─────────────────────────────────────────
+// ─── refresh() API ──────────────────────────────────────────────────────────
 
-describe("invalidateQueries() — simplified broadcast-only", () => {
-    it("빈 배열이면 아무것도 전송하지 않는다 (emit() 방식 no-op)", async () => {
-        const ws = makeMockWs();
-        registerClient(ws);
-
-        const mockCtx = {} as GencowCtx;
-        await invalidateQueries([], mockCtx);
+describe("refresh() — 서버 쿼리 재실행 요청 큐", () => {
+    it("refresh()로 등록된 queryKey가 _pendingRefresh에 큐잉된다", () => {
+        const rt = buildRealtimeCtx();
+        rt.refresh("tasks.list");
 
-        expect(ws._sent).toHaveLength(0);
-        deregisterClient(ws);
+        expect((rt as any)._pendingRefresh).toContain("tasks.list");
     });
 
-    it("queryKeys가 있으면 connectedClients 전체에 invalidate broadcast를 보낸다", async () => {
-        const ws = makeMockWs();
-        registerClient(ws);
-
-        const mockCtx = {} as GencowCtx;
-        await invalidateQueries(["tasks.list"], mockCtx);
-
-        expect(ws._sent).toHaveLength(1);
-        const msg = JSON.parse(ws._sent[0]);
-        expect(msg.type).toBe("invalidate");
-        expect(msg.queries).toEqual(["tasks.list"]);
+    it("동일 queryKey 중복 refresh는 한 번만 큐잉된다", () => {
+        const rt = buildRealtimeCtx();
+        rt.refresh("tasks.list");
+        rt.refresh("tasks.list");
+        rt.refresh("tasks.list");
 
-        deregisterClient(ws);
+        const count = (rt as any)._pendingRefresh.filter((k: string) => k === "tasks.list").length;
+        expect(count).toBe(1);
     });
 
-    it("서버에서 쿼리를 재실행하지 않는다 (query:updated 미전송)", async () => {
-        const ws = makeMockWs();
-        registerClient(ws);
-
-        const mockCtx = {} as GencowCtx;
-        await invalidateQueries(["tasks.list", "tasks.get"], mockCtx);
-
-        // query:updated 메시지가 없어야 함
-        const types = ws._sent.map((s: string) => JSON.parse(s).type);
-        expect(types.every((t: string) => t === "invalidate")).toBe(true);
+    it("서로 다른 queryKey는 각각 큐잉된다", () => {
+        const rt = buildRealtimeCtx();
+        rt.refresh("tasks.list");
+        rt.refresh("users.list");
 
-        deregisterClient(ws);
+        expect((rt as any)._pendingRefresh).toContain("tasks.list");
+        expect((rt as any)._pendingRefresh).toContain("users.list");
     });
 });
 
-// ─── buildRealtimeCtx + invalidateQueries 공존 시나리오 ─────────────────────
-
-describe("emit() 방식과 legacy invalidateQueries() 혼용", () => {
-    it("emit()은 query:updated, invalidateQueries()는 invalidate를 각각 전송한다", async () => {
-        const wsSubscribed = makeMockWs(); // query 구독 클라이언트
-        const wsConnected = makeMockWs(); // 연결만 된 클라이언트 (대시보드)
+// ─── emit()과 refresh() 병행 시나리오 ───────────────────────────────────────
 
+describe("emit()과 refresh() 병행", () => {
+    it("emit()은 query:updated를 구독자에게 즉시 push한다", async () => {
+        const wsSubscribed = makeMockWs();
         subscribe("items.list", wsSubscribed);
-        registerClient(wsConnected);
 
-        // 1. emit() — 구독자에게만 query:updated
         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);
-        // connectedClients에만 등록된 ws는 query:updated 미수신
-        expect(wsConnected._sent).toHaveLength(0);
 
-        // 2. invalidateQueries() — ALL connectedClients에 invalidate broadcast
-        const mockCtx = {} as GencowCtx;
-        await invalidateQueries(["items.list"], mockCtx);
+        deregisterClient(wsSubscribed);
+    });
 
-        expect(wsConnected._sent).toHaveLength(1);
-        expect(JSON.parse(wsConnected._sent[0]).type).toBe("invalidate");
+    it("emit() 호출 후 _hasEmitted가 true로 설정된다", () => {
+        const rt = buildRealtimeCtx();
+        expect((rt as any)._hasEmitted).toBe(false);
 
-        deregisterClient(wsSubscribed);
-        deregisterClient(wsConnected);
+        const ws = makeMockWs();
+        subscribe("flag.test", ws);
+        rt.emit("flag.test", [{ id: 1 }]);
+
+        expect((rt as any)._hasEmitted).toBe(true);
+
+        deregisterClient(ws);
     });
 });
 
@@ -206,7 +191,6 @@ describe("Secure by Default — public 플래그", () => {
     it("mutation() 기본값은 isPublic === false", () => {
         const m = mutation({
             name: "sectest.mut.private",
-            invalidates: [],
             handler: async () => ({ ok: true }),
         });
         expect(m.isPublic).toBe(false);
@@ -215,7 +199,6 @@ describe("Secure by Default — public 플래그", () => {
     it("mutation({ public: true }) 시 isPublic === true", () => {
         const m = mutation({
             name: "sectest.mut.public",
-            invalidates: [],
             public: true,
             handler: async () => ({ ok: true }),
         });
@@ -243,7 +226,7 @@ describe("mutation(name, def) — query와 동일 패턴", () => {
         const m = mutation("newsig.basic", {
             handler: async () => ({ ok: true }),
         });
-        expect((m as any).name || (getRegisteredMutations().find(x => x.invalidates.length === 0 && x.handler === (m as any).handler) as any)?.name).toBeDefined();
+        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();
@@ -258,35 +241,35 @@ describe("mutation(name, def) — query와 동일 패턴", () => {
         expect(m.isPublic).toBe(true);
     });
 
-    it("invalidates 미지정 시 빈 배열이 기본값", () => {
+    it("invalidates 미지정 시 빈 배열이 기본값 (하위호환)", () => {
         const m = mutation("newsig.noInvalidates", {
             handler: async () => ({ ok: true }),
         });
         const all = getRegisteredMutations();
         const found = all.find(x => x.name === "newsig.noInvalidates");
-        expect(found!.invalidates).toEqual([]);
+        // invalidates는 deprecated이지만 빈 배열로 유지 (하위호환)
+        expect(found).toBeDefined();
     });
 
-    it("invalidates 지정 시 올바르게 전달된다", () => {
+    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");
-        expect(found!.invalidates).toEqual(["tasks.list", "tasks.get"]);
+        // invalidates는 deprecated — 전달해도 런타임에서 무시됨
+        expect(found).toBeDefined();
     });
 
     it("기존 객체 스타일도 여전히 동작한다 (하위 호환)", () => {
         const m = mutation({
             name: "newsig.compat.object",
-            invalidates: ["a.list"],
             handler: async () => ({ ok: true }),
         });
         const all = getRegisteredMutations();
         const found = all.find(x => x.name === "newsig.compat.object");
         expect(found).toBeDefined();
-        expect(found!.invalidates).toEqual(["a.list"]);
     });
 
     it("기존 배열 스타일도 여전히 동작한다 (하위 호환)", () => {
@@ -294,7 +277,6 @@ describe("mutation(name, def) — query와 동일 패턴", () => {
         const all = getRegisteredMutations();
         const found = all.find(x => x.name === "newsig.compat.array");
         expect(found).toBeDefined();
-        expect(found!.invalidates).toEqual(["b.list"]);
     });
 
     it("이름 미지정 시 console.warn이 호출된다", () => {

package/src/__tests__/storage.test.ts

@@ -206,3 +206,116 @@ describe("createStorage()", () => {
         });
     });
 });
+
+// ─── _system_files 테이블 리네이밍 관련 테스트 ────────────
+// 2026-04-10 WSOD 사고 후 추가: files → _system_files 리네이밍 검증
+// 📄 참고: docs/analysis/analysis-files-page-wsod.md
+
+describe("_system_files 시스템 테이블 네이밍", () => {
+    it("rawSql로 실행되는 모든 SQL에 old 'files' 테이블 참조가 없다", async () => {
+        const executedSql: string[] = [];
+        const mockRawSql = async (sql: string) => {
+            executedSql.push(sql);
+            if (sql.includes("SUM")) return [{ total: "0" }];
+            if (sql.includes("INSERT")) return [];
+            return [];
+        };
+
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gencow-naming-"));
+        const storage = createStorage(tmpDir, { rawSql: mockRawSql });
+
+        // store 트리거 (ensureFilesTable + checkQuota + recordFileToDb)
+        const file = new File(["test"], "test.txt", { type: "text/plain" });
+        try { await storage.store(file); } catch {}
+
+        // 모든 실행된 SQL에서 old 테이블명 'files'가 아닌 '_system_files'만 참조하는지 확인
+        // (files 단독 참조를 찾되, _system_files는 통과)
+        for (const sql of executedSql) {
+            // "FROM files", "INTO files", "TABLE files" 같은 old 패턴이 없어야 함
+            expect(sql).not.toMatch(/\bFROM\s+files\b(?!_)/i);
+            expect(sql).not.toMatch(/\bINTO\s+files\b(?!_)/i);
+            expect(sql).not.toMatch(/\bTABLE\s+files\b(?!_)/i);
+        }
+
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+    });
+
+    it("쿼터 검증 SQL이 _system_files 테이블을 참조한다", async () => {
+        const executedSql: string[] = [];
+        const mockRawSql = async (sql: string) => {
+            executedSql.push(sql);
+            if (sql.includes("SUM")) return [{ total: "0" }];
+            if (sql.includes("INSERT")) return [];
+            return [];
+        };
+
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gencow-quota-"));
+        const storage = createStorage(tmpDir, {
+            rawSql: mockRawSql,
+            storageQuota: 1000000000,
+        });
+
+        const file = new File(["small"], "small.txt");
+        try { await storage.store(file); } catch {}
+
+        // SUM 쿼리가 _system_files 테이블을 참조하는지 확인
+        const sumSql = executedSql.find(s => s.includes("SUM"));
+        if (sumSql) {
+            expect(sumSql).toContain("_system_files");
+            expect(sumSql).not.toMatch(/FROM\s+files[^_]/);
+        }
+
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+    });
+
+    it("recordFileToDb SQL이 _system_files 테이블에 INSERT한다", async () => {
+        const executedSql: string[] = [];
+        const mockRawSql = async (sql: string) => {
+            executedSql.push(sql);
+            if (sql.includes("SUM")) return [{ total: "0" }];
+            return [];
+        };
+
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gencow-insert-"));
+        const storage = createStorage(tmpDir, { rawSql: mockRawSql });
+
+        const file = new File(["data"], "data.txt", { type: "text/plain" });
+        try { await storage.store(file); } catch {}
+
+        const insertSql = executedSql.find(s => s.includes("INSERT"));
+        if (insertSql) {
+            expect(insertSql).toContain("_system_files");
+            expect(insertSql).not.toMatch(/INTO\s+files[^_]/);
+        }
+
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+    });
+
+    it("delete SQL이 _system_files 테이블에서 삭제한다", async () => {
+        const executedSql: string[] = [];
+        const mockRawSql = async (sql: string) => {
+            executedSql.push(sql);
+            if (sql.includes("SUM")) return [{ total: "0" }];
+            return [];
+        };
+
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gencow-delete-"));
+        const storage = createStorage(tmpDir, { rawSql: mockRawSql });
+
+        // store 후 delete
+        const file = new File(["delete-me"], "del.txt");
+        let storageId: string | undefined;
+        try { storageId = await storage.store(file); } catch {}
+        if (storageId) {
+            try { await storage.delete(storageId); } catch {}
+        }
+
+        const deleteSql = executedSql.find(s => s.includes("DELETE"));
+        if (deleteSql) {
+            expect(deleteSql).toContain("_system_files");
+            expect(deleteSql).not.toMatch(/FROM\s+files[^_]/);
+        }
+
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+    });
+});

package/src/__tests__/validator.test.ts

@@ -281,4 +281,39 @@ describe("parseArgs()", () => {
         expect(err.statusCode).toBe(400);
         expect(err.name).toBe("GencowValidationError");
     });
+
+    // ─── 빈 스키마 passthrough (FormData 업로드 버그 회귀 방지) ────
+
+    it("빈 스키마 {} → args 전체 passthrough (FormData file 필드 보존)", () => {
+        const schema = {};
+        const args = { file: new File(["hello"], "test.txt"), _mutation: "upload.store" };
+        const result = parseArgs(schema, args);
+        // 빈 스키마이므로 args가 그대로 반환되어야 함 (file 포함)
+        expect(result).toBe(args); // 참조 동일
+        expect(result.file).toBeInstanceOf(File);
+        expect(result._mutation).toBe("upload.store");
+    });
+
+    it("빈 스키마 {} + 일반 객체 → passthrough", () => {
+        const schema = {};
+        const args = { name: "test", count: 42, nested: { a: 1 } };
+        const result = parseArgs(schema, args);
+        expect(result).toBe(args);
+        expect(result.name).toBe("test");
+        expect(result.count).toBe(42);
+    });
+
+    it("빈 스키마 {} + 빈 args {} → 빈 객체 반환", () => {
+        const result = parseArgs({}, {});
+        expect(result).toEqual({});
+    });
+
+    it("키가 있는 스키마는 여전히 지정된 키만 추출 (file 제거됨)", () => {
+        const schema = { title: v.string() };
+        const args = { title: "hello", file: "should-be-stripped", extra: 123 };
+        const result = parseArgs(schema, args);
+        expect(result).toEqual({ title: "hello" });
+        expect(result.file).toBeUndefined();
+        expect(result.extra).toBeUndefined();
+    });
 });

package/src/crud.ts

@@ -354,7 +354,6 @@ export function crud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
 
     const createDef = !enabledMethods.has('create') ? undefined : mutation(`${prefix}.create`, {
         public: isPublic,
-        invalidates: [],
         handler: async (ctx: any, args: any) => {
             const user = isPublic ? null : ctx.auth.requireAuth();
 
@@ -386,7 +385,6 @@ export function crud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
 
     const updateDef = !enabledMethods.has('update') ? undefined : mutation(`${prefix}.update`, {
         public: isPublic,
-        invalidates: [],
         handler: async (ctx: any, args: any) => {
             if (!isPublic) ctx.auth.requireAuth();
 
@@ -428,7 +426,6 @@ export function crud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
 
     const removeDef = !enabledMethods.has('remove') ? undefined : mutation(`${prefix}.remove`, {
         public: isPublic,
-        invalidates: [],
         handler: async (ctx: any, args: any) => {
             if (!isPublic) ctx.auth.requireAuth();
 

package/src/index.ts

@@ -6,7 +6,7 @@
  */
 
 export type { GencowCtx, AuthCtx, UserIdentity, QueryDef, MutationDef, RealtimeCtx, HttpActionDef, HttpActionRequest, HttpActionResponse, HttpActionHandler, AIContext, AIMessage, AIResult } from "./reactive";
-export { query, mutation, httpAction, invalidateQueries, buildRealtimeCtx, subscribe, unsubscribe, registerClient, deregisterClient, handleWsMessage, getQueryHandler, getQueryDef, getRegisteredQueries, getRegisteredMutations, getRegisteredHttpActions } from "./reactive";
+export { query, mutation, httpAction, buildRealtimeCtx, subscribe, unsubscribe, registerClient, deregisterClient, handleWsMessage, getQueryHandler, getQueryDef, getRegisteredQueries, getRegisteredMutations, getRegisteredHttpActions } from "./reactive";
 export type { Storage } from "./storage";
 export { createScheduler, getSchedulerInfo } from "./scheduler";
 export type { Scheduler, ScheduleOptions, FailedJob } from "./scheduler";