@gencow/core 0.1.18 → 0.1.19

package/dist/storage.js

@@ -18,8 +18,9 @@ function formatBytes(bytes) {
 // ─── Implementation ─────────────────────────────────────
 const metaStore = new Map();
 /**
- * files 테이블 자동 생성 (이미 존재하면 무시)
+ * _system_files 테이블 자동 생성 (이미 존재하면 무시)
  * admin.ts의 CREATE_FILES_TABLE_SQL과 동일한 스키마 사용
+ * ⚠️ 테이블명 '_system_files' — 사용자 테이블과 네이밍 충돌 방지 (2026-04-10)
  */
 let filesTableEnsured = false;
 async function ensureFilesTable(rawSql) {
@@ -31,9 +32,9 @@ async function ensureFilesTable(rawSql) {
             IF NOT EXISTS (
                 SELECT 1 FROM information_schema.tables
                 WHERE table_schema = current_schema()
-                AND table_name = 'files'
+                AND table_name = '_system_files'
             ) THEN
-                CREATE TABLE files (
+                CREATE TABLE _system_files (
                     id SERIAL PRIMARY KEY,
                     storage_id TEXT NOT NULL,
                     name TEXT NOT NULL,
@@ -53,7 +54,7 @@ async function ensureFilesTable(rawSql) {
 async function checkStorageQuota(rawSql, newFileSize, quota) {
     if (quota <= 0)
         return; // 무제한
-    const rows = await rawSql(`SELECT COALESCE(SUM(CAST(size AS BIGINT)), 0) AS total FROM files`);
+    const rows = await rawSql(`SELECT COALESCE(SUM(CAST(size AS BIGINT)), 0) AS total FROM _system_files`);
     const currentUsage = Number(rows[0]?.total || "0");
     const projectedUsage = currentUsage + newFileSize;
     if (projectedUsage > quota) {
@@ -69,7 +70,7 @@ async function checkStorageQuota(rawSql, newFileSize, quota) {
  */
 async function recordFileToDb(rawSql, storageId, name, size, type, uploadedBy = "api") {
     await ensureFilesTable(rawSql);
-    await rawSql(`INSERT INTO files (storage_id, name, size, type, uploaded_by, created_at)
+    await rawSql(`INSERT INTO _system_files (storage_id, name, size, type, uploaded_by, created_at)
          VALUES ($1, $2, $3, $4, $5, NOW())`, [storageId, name, String(size), type, uploadedBy]);
 }
 /**
@@ -170,7 +171,7 @@ export function createStorage(dir = "./uploads", options) {
             // DB에서도 삭제 (rawSql 있을 때만)
             if (rawSql) {
                 try {
-                    await rawSql(`DELETE FROM files WHERE storage_id = $1`, [storageId]);
+                    await rawSql(`DELETE FROM _system_files WHERE storage_id = $1`, [storageId]);
                 }
                 catch { /* 삭제 실패 무시 — 파일은 이미 제거됨 */ }
             }
@@ -190,7 +191,7 @@ export function storageRoutes(storage, rawSql, storageDir) {
         // Fallback: DB lookup when in-memory meta is missing (e.g. after server restart)
         if (!meta && rawSql) {
             try {
-                const rows = await rawSql(`SELECT storage_id, name, size, type FROM files WHERE storage_id = $1 LIMIT 1`, [id]);
+                const rows = await rawSql(`SELECT storage_id, name, size, type FROM _system_files WHERE storage_id = $1 LIMIT 1`, [id]);
                 if (rows.length > 0) {
                     const row = rows[0];
                     const dir = storageDir || "./uploads";

package/dist/v.js

@@ -113,11 +113,15 @@ export function parseArgs(schema, args) {
     }
     // Shorthand object — e.g. { id: v.number(), title: v.optional(v.string()) }
     if (typeof schema === "object" && schema !== null) {
+        // Empty schema {} → passthrough all args (e.g. FormData with file field)
+        const schemaKeys = Object.keys(schema);
+        if (schemaKeys.length === 0)
+            return args;
         if (typeof args !== "object" || args === null) {
             throw new GencowValidationError("Expected an object for arguments");
         }
         const result = {};
-        for (const key in schema) {
+        for (const key of schemaKeys) {
             const validator = schema[key];
             if (validator && typeof validator.parse === "function") {
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gencow/core",
-    "version": "0.1.18",
+    "version": "0.1.19",
     "description": "Gencow core library — defineQuery, defineMutation, reactive subscriptions",
     "type": "module",
     "main": "dist/index.js",

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/storage.ts

@@ -52,8 +52,9 @@ export interface Storage {
 const metaStore = new Map<string, StorageFile>();
 
 /**
- * files 테이블 자동 생성 (이미 존재하면 무시)
+ * _system_files 테이블 자동 생성 (이미 존재하면 무시)
  * admin.ts의 CREATE_FILES_TABLE_SQL과 동일한 스키마 사용
+ * ⚠️ 테이블명 '_system_files' — 사용자 테이블과 네이밍 충돌 방지 (2026-04-10)
  */
 let filesTableEnsured = false;
 
@@ -67,9 +68,9 @@ async function ensureFilesTable(
             IF NOT EXISTS (
                 SELECT 1 FROM information_schema.tables
                 WHERE table_schema = current_schema()
-                AND table_name = 'files'
+                AND table_name = '_system_files'
             ) THEN
-                CREATE TABLE files (
+                CREATE TABLE _system_files (
                     id SERIAL PRIMARY KEY,
                     storage_id TEXT NOT NULL,
                     name TEXT NOT NULL,
@@ -95,7 +96,7 @@ async function checkStorageQuota(
     if (quota <= 0) return; // 무제한
 
     const rows = await rawSql(
-        `SELECT COALESCE(SUM(CAST(size AS BIGINT)), 0) AS total FROM files`,
+        `SELECT COALESCE(SUM(CAST(size AS BIGINT)), 0) AS total FROM _system_files`,
     );
     const currentUsage = Number((rows[0] as Record<string, string>)?.total || "0");
     const projectedUsage = currentUsage + newFileSize;
@@ -124,7 +125,7 @@ async function recordFileToDb(
 ): Promise<void> {
     await ensureFilesTable(rawSql);
     await rawSql(
-        `INSERT INTO files (storage_id, name, size, type, uploaded_by, created_at)
+        `INSERT INTO _system_files (storage_id, name, size, type, uploaded_by, created_at)
          VALUES ($1, $2, $3, $4, $5, NOW())`,
         [storageId, name, String(size), type, uploadedBy],
     );
@@ -258,7 +259,7 @@ export function createStorage(
             if (rawSql) {
                 try {
                     await rawSql(
-                        `DELETE FROM files WHERE storage_id = $1`,
+                        `DELETE FROM _system_files WHERE storage_id = $1`,
                         [storageId],
                     );
                 } catch { /* 삭제 실패 무시 — 파일은 이미 제거됨 */ }
@@ -286,7 +287,7 @@ export function storageRoutes(
         if (!meta && rawSql) {
             try {
                 const rows = await rawSql(
-                    `SELECT storage_id, name, size, type FROM files WHERE storage_id = $1 LIMIT 1`,
+                    `SELECT storage_id, name, size, type FROM _system_files WHERE storage_id = $1 LIMIT 1`,
                     [id]
                 );
                 if (rows.length > 0) {

package/src/v.ts

@@ -135,11 +135,15 @@ export function parseArgs(schema: any, args: any): any {
 
     // Shorthand object — e.g. { id: v.number(), title: v.optional(v.string()) }
     if (typeof schema === "object" && schema !== null) {
+        // Empty schema {} → passthrough all args (e.g. FormData with file field)
+        const schemaKeys = Object.keys(schema);
+        if (schemaKeys.length === 0) return args;
+
         if (typeof args !== "object" || args === null) {
             throw new GencowValidationError("Expected an object for arguments");
         }
         const result: any = {};
-        for (const key in schema) {
+        for (const key of schemaKeys) {
             const validator = schema[key];
             if (validator && typeof validator.parse === "function") {
                 try {