gencow 0.1.114 → 0.1.116

package/bin/gencow.mjs

@@ -1718,6 +1718,10 @@ ${BOLD}BaaS commands (login required):${RESET}
   ${GREEN}env set K=V${RESET}      Set cloud env var ${DIM}(hot-reload, no restart)${RESET}
   ${GREEN}env unset KEY${RESET}    Remove cloud env var
   ${GREEN}env push${RESET}         Push .env to cloud
+  ${GREEN}files upload${RESET}     Upload files to app storage ${DIM}(--recursive for dirs)${RESET}
+  ${GREEN}files list${RESET}       List uploaded files
+  ${GREEN}files delete${RESET}     Delete uploaded file ${DIM}(--yes to skip confirm)${RESET}
+  ${GREEN}files url${RESET}        Get serving URL for a file
   ${GREEN}domain set${RESET}       Connect custom domain ${DIM}(myapp.com)${RESET}
   ${GREEN}domain status${RESET}    Check domain DNS/TLS status
   ${GREEN}domain remove${RESET}    Disconnect custom domain
@@ -2981,6 +2985,297 @@ ${BOLD}Examples:${RESET}
         },
 
 
+    // ── files ─────────────────────────────────────────────
+    async files(...filesArgs) {
+            const subCmd = filesArgs[0] || "help";
+            const restArgs = filesArgs.slice(1);
+
+            // help는 인증/앱 정보 없이도 표시
+            if (subCmd === "help" || subCmd === "--help" || subCmd === "-h") {
+                log(`\n${BOLD}${CYAN}gencow files${RESET} — 파일 관리\n`);
+                log(`  ${CYAN}upload${RESET} <경로...> [--recursive|-r]  파일 업로드`);
+                log(`  ${CYAN}list${RESET}                              파일 목록`);
+                log(`  ${CYAN}delete${RESET} <storage_id> [--yes|-y]     파일 삭제`);
+                log(`  ${CYAN}url${RESET}    <storage_id>               서빙 URL 출력`);
+                log(`\n  ${DIM}옵션:${RESET}`);
+                log(`    ${DIM}--app, -a <앱이름>  대상 앱 지정 (기본: gencow.json)${RESET}\n`);
+                return;
+            }
+
+            const creds = requireCreds();
+
+            // 앱 ID 결정 + --app 플래그 위치 추적 (paths 필터링용)
+            let appId = null;
+            const flagIndices = new Set(); // --app와 그 값의 인덱스
+            for (let i = 0; i < restArgs.length; i++) {
+                if (restArgs[i] === "--app" || restArgs[i] === "-a") {
+                    flagIndices.add(i);
+                    flagIndices.add(i + 1);
+                    appId = restArgs[++i];
+                }
+            }
+
+            if (!appId) {
+                const gencowJsonPath = resolve(process.cwd(), "gencow.json");
+                if (existsSync(gencowJsonPath)) {
+                    const gencowJson = JSON.parse(readFileSync(gencowJsonPath, "utf8"));
+                    appId = gencowJson.appId || gencowJson.appName;
+                }
+            }
+
+            if (!appId) {
+                error("앱 ID를 찾을 수 없습니다. gencow deploy를 먼저 실행하세요.");
+                return;
+            }
+
+            const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50 MB
+
+            function fmtFileSize(bytes) {
+                if (bytes < 1024) return `${bytes} B`;
+                if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+                return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+            }
+
+            function fmtDate(d) {
+                return new Date(d).toLocaleString("ko-KR", {
+                    year: "numeric", month: "2-digit", day: "2-digit",
+                    hour: "2-digit", minute: "2-digit",
+                });
+            }
+
+            /** 파일 서빙 URL 생성 */
+            function getFileUrl(storageId) {
+                return `${getAppUrl(appId, creds.platformUrl)}/api/storage/${storageId}`;
+            }
+
+            /** 단일 파일 업로드 */
+            async function uploadFile(filePath) {
+                const fileName = basename(filePath);
+                const stat = statSync(filePath);
+
+                // 로컬 크기 검증 (서버 왕복 방지)
+                if (stat.size > MAX_FILE_SIZE) {
+                    error(`${fileName}: ${fmtFileSize(stat.size)} — 50MB 제한 초과`);
+                    return null;
+                }
+
+                info(`${fileName} (${fmtFileSize(stat.size)}) 업로드 중...`);
+
+                const fileBuffer = readFileSync(filePath);
+                const blob = new Blob([fileBuffer]);
+
+                const formData = new FormData();
+                formData.append("file", blob, fileName);
+
+                try {
+                    const res = await fetch(
+                        `${creds.platformUrl}/platform/files/upload?appName=${appId}`,
+                        {
+                            method: "POST",
+                            headers: {
+                                "Authorization": `Bearer ${creds.apiKey}`,
+                            },
+                            body: formData,
+                        }
+                    );
+
+                    const data = await res.json().catch(() => ({}));
+                    if (!res.ok) {
+                        error(`${fileName}: ${data.error || res.statusText}`);
+                        return null;
+                    }
+
+                    success(`${fileName} → ${data.storageId}`);
+                    info(`  URL: ${getFileUrl(data.storageId)}`);
+                    return data;
+                } catch (err) {
+                    error(`${fileName}: ${err.message}`);
+                    return null;
+                }
+            }
+
+            /** 디렉토리 재귀 파일 수집 */
+            function collectFiles(dirPath) {
+                const results = [];
+                const entries = readdirSync(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const full = resolve(dirPath, entry.name);
+                    if (entry.isDirectory()) {
+                        results.push(...collectFiles(full));
+                    } else if (entry.isFile()) {
+                        results.push(full);
+                    }
+                }
+                return results;
+            }
+
+            switch (subCmd) {
+                case "upload":
+                case "up": {
+                    const recursive = restArgs.includes("--recursive") || restArgs.includes("-r");
+                    const paths = restArgs.filter((a, i) => !a.startsWith("-") && !flagIndices.has(i));
+
+                    if (paths.length === 0) {
+                        error("사용법: gencow files upload <파일|폴더 경로...> [--recursive|-r]");
+                        return;
+                    }
+
+                    let filesToUpload = [];
+                    for (const p of paths) {
+                        const resolved = resolve(process.cwd(), p);
+                        if (!existsSync(resolved)) {
+                            error(`파일을 찾을 수 없습니다: ${p}`);
+                            continue;
+                        }
+                        const stat = statSync(resolved);
+                        if (stat.isDirectory()) {
+                            if (!recursive) {
+                                error(`${p}는 디렉토리입니다. --recursive (-r) 옵션을 사용하세요.`);
+                                continue;
+                            }
+                            filesToUpload.push(...collectFiles(resolved));
+                        } else {
+                            filesToUpload.push(resolved);
+                        }
+                    }
+
+                    if (filesToUpload.length === 0) {
+                        error("업로드할 파일이 없습니다.");
+                        return;
+                    }
+
+                    log(`\n${BOLD}${CYAN}파일 업로드${RESET} — ${appId}\n`);
+                    info(`${filesToUpload.length}개 파일 업로드 시작...\n`);
+
+                    let uploaded = 0;
+                    let failed = 0;
+                    for (const filePath of filesToUpload) {
+                        const result = await uploadFile(filePath);
+                        if (result) uploaded++;
+                        else failed++;
+                    }
+
+                    log("");
+                    if (uploaded > 0) success(`${uploaded}개 파일 업로드 완료`);
+                    if (failed > 0) warn(`${failed}개 파일 실패`);
+                    break;
+                }
+
+                case "list":
+                case "ls": {
+                    log(`\n${BOLD}${CYAN}파일 목록${RESET} — ${appId}\n`);
+
+                    const res = await fetch(
+                        `${creds.platformUrl}/platform/files/list`,
+                        {
+                            method: "POST",
+                            headers: {
+                                "Authorization": `Bearer ${creds.apiKey}`,
+                                "Content-Type": "application/json",
+                            },
+                            body: JSON.stringify({ appName: appId }),
+                        }
+                    );
+
+                    const data = await res.json().catch(() => []);
+                    if (!res.ok) {
+                        error(data.error || "파일 목록 조회 실패");
+                        return;
+                    }
+
+                    const files = Array.isArray(data) ? data : [];
+                    if (files.length === 0) {
+                        info("저장된 파일이 없습니다.");
+                        log("");
+                        return;
+                    }
+
+                    // 테이블 형식 출력
+                    const idWidth = Math.max(12, ...files.map(f => (f.storage_id || "").length));
+                    const nameWidth = Math.max(8, ...files.map(f => (f.name || "").length).map(l => Math.min(l, 40)));
+
+                    log(`  ${DIM}${"ID".padEnd(idWidth)}  ${"이름".padEnd(nameWidth)}  ${"크기".padStart(10)}  ${"소스".padEnd(10)}  업로드 시각${RESET}`);
+                    log(`  ${DIM}${"─".repeat(idWidth)}  ${"─".repeat(nameWidth)}  ${"─".repeat(10)}  ${"─".repeat(10)}  ${"─".repeat(16)}${RESET}`);
+
+                    for (const f of files) {
+                        const name = (f.name || "").length > 40 ? f.name.slice(0, 37) + "..." : (f.name || "");
+                        const size = fmtFileSize(Number(f.size) || 0).padStart(10);
+                        const source = (f.uploaded_by || "api").padEnd(10);
+                        const date = f.created_at ? fmtDate(f.created_at) : "-";
+                        log(`  ${(f.storage_id || "").padEnd(idWidth)}  ${name.padEnd(nameWidth)}  ${size}  ${source}  ${date}`);
+                    }
+                    log(`\n  ${DIM}총 ${files.length}개 파일${RESET}\n`);
+                    break;
+                }
+
+                case "delete":
+                case "rm": {
+                    const storageId = restArgs.find((a, i) => !a.startsWith("-") && !flagIndices.has(i));
+                    if (!storageId) {
+                        error("사용법: gencow files delete <storage_id>");
+                        return;
+                    }
+
+                    // 확인 프롬프트
+                    const skipConfirm = restArgs.includes("--yes") || restArgs.includes("-y");
+                    if (!skipConfirm) {
+                        const { createInterface } = await import("readline");
+                        const rl = createInterface({ input: process.stdin, output: process.stdout });
+                        const answer = await new Promise(resolve => {
+                            rl.question(`\n  ${YELLOW}정말 삭제하시겠습니까?${RESET} ${DIM}${storageId}${RESET} (y/N): `, a => {
+                                rl.close();
+                                resolve(a.trim().toLowerCase());
+                            });
+                        });
+                        if (answer !== "y" && answer !== "yes") {
+                            info("삭제를 취소했습니다.");
+                            return;
+                        }
+                    }
+
+                    const res = await fetch(
+                        `${creds.platformUrl}/platform/files/delete`,
+                        {
+                            method: "POST",
+                            headers: {
+                                "Authorization": `Bearer ${creds.apiKey}`,
+                                "Content-Type": "application/json",
+                            },
+                            body: JSON.stringify({ appName: appId, storageId }),
+                        }
+                    );
+
+                    const data = await res.json().catch(() => ({}));
+                    if (res.ok && data.success) {
+                        success(`파일 삭제 완료: ${storageId}`);
+                    } else {
+                        error(`삭제 실패: ${data.error || res.statusText}`);
+                    }
+                    break;
+                }
+
+                case "url": {
+                    const storageId = restArgs.find((a, i) => !a.startsWith("-") && !flagIndices.has(i));
+                    if (!storageId) {
+                        error("사용법: gencow files url <storage_id>");
+                        return;
+                    }
+                    log(getFileUrl(storageId));
+                    break;
+                }
+
+                default:
+                    if (subCmd !== "help") error(`알 수 없는 하위 명령: ${subCmd}`);
+                    log(`\n${BOLD}${CYAN}gencow files${RESET} — 파일 관리\n`);
+                    log(`  ${CYAN}upload${RESET} <경로...> [--recursive|-r]  파일 업로드`);
+                    log(`  ${CYAN}list${RESET}                              파일 목록`);
+                    log(`  ${CYAN}delete${RESET} <storage_id> [--yes|-y]     파일 삭제`);
+                    log(`  ${CYAN}url${RESET}    <storage_id>               서빙 URL 출력`);
+                    log(`\n  ${DIM}옵션:${RESET}`);
+                    log(`    ${DIM}--app, -a <앱이름>  대상 앱 지정 (기본: gencow.json)${RESET}\n`);
+            }
+        },
+
     // ── backup ─────────────────────────────────────────────
     async backup(...backupArgs) {
             const creds = requireCreds();

package/core/index.js

@@ -1402,7 +1402,6 @@ function query(key, handlerOrDef) {
 }
 var mutationCounter = 0;
 function mutation(nameOrInvalidatesOrDef, handlerOrDef, name) {
-  let invalidates;
   let argsSchema;
   let actualHandler;
   let mutName;
@@ -1410,16 +1409,13 @@ function mutation(nameOrInvalidatesOrDef, handlerOrDef, name) {
   if (typeof nameOrInvalidatesOrDef === "string") {
     mutName = nameOrInvalidatesOrDef;
     const def2 = handlerOrDef;
-    invalidates = def2.invalidates || [];
     actualHandler = def2.handler;
     argsSchema = def2.args;
     isPublic = def2.public === true;
   } else if (Array.isArray(nameOrInvalidatesOrDef)) {
-    invalidates = nameOrInvalidatesOrDef;
     actualHandler = handlerOrDef;
     mutName = name || `mutation_${++mutationCounter}`;
   } else {
-    invalidates = nameOrInvalidatesOrDef.invalidates;
     actualHandler = nameOrInvalidatesOrDef.handler;
     argsSchema = nameOrInvalidatesOrDef.args;
     isPublic = nameOrInvalidatesOrDef.public === true;
@@ -1432,7 +1428,6 @@ function mutation(nameOrInvalidatesOrDef, handlerOrDef, name) {
   }
   const def = {
     name: mutName,
-    invalidates,
     handler: actualHandler,
     argsSchema,
     isPublic
@@ -1477,8 +1472,11 @@ function deregisterClient(ws) {
 }
 function buildRealtimeCtx(options) {
   const pendingEmits = /* @__PURE__ */ new Map();
+  const _pendingRefresh = [];
+  let _hasEmitted = false;
   return {
     emit(queryKey, data) {
+      _hasEmitted = true;
       const existing = pendingEmits.get(queryKey);
       if (existing) clearTimeout(existing.timer);
       const timer = setTimeout(() => {
@@ -1503,24 +1501,58 @@ function buildRealtimeCtx(options) {
         }
       }, 50);
       pendingEmits.set(queryKey, { data, timer });
+    },
+    refresh(queryKey) {
+      _hasEmitted = true;
+      if (!_pendingRefresh.includes(queryKey)) {
+        _pendingRefresh.push(queryKey);
+      }
+    },
+    get _hasEmitted() {
+      return _hasEmitted;
+    },
+    get _pendingRefresh() {
+      return [..._pendingRefresh];
+    },
+    async _flushRefresh() {
+      if (_pendingRefresh.length === 0) return;
+      const qMap = options?.queryMap ?? queryRegistry;
+      for (const key of _pendingRefresh) {
+        const queryDef = qMap.get(key);
+        if (!queryDef) {
+          console.warn(`[gencow] refresh("${key}"): query not found in registry. Skipping.`);
+          continue;
+        }
+        try {
+          const refreshCtx = options?.buildCtxForRefresh?.() ?? {};
+          const result = await queryDef.handler(refreshCtx, {});
+          if (options?.httpCallback) {
+            options.httpCallback({ type: "emit", queryKey: key, data: result });
+          } else {
+            const clients = subscribers.get(key);
+            if (clients && clients.size > 0) {
+              const message = JSON.stringify({
+                type: "query:updated",
+                query: key,
+                data: result
+              });
+              for (const ws of clients) {
+                try {
+                  ws.send(message);
+                } catch {
+                  clients.delete(ws);
+                }
+              }
+            }
+          }
+        } catch (e) {
+          console.warn(`[gencow] refresh("${key}") failed:`, e instanceof Error ? e.message : e);
+        }
+      }
+      _pendingRefresh.length = 0;
     }
   };
 }
-async function invalidateQueries(queryKeys, ctx, httpInvalidateCallback) {
-  if (queryKeys.length === 0) return;
-  if (httpInvalidateCallback) {
-    httpInvalidateCallback(queryKeys);
-    return;
-  }
-  const invalidateMsg = JSON.stringify({ type: "invalidate", queries: queryKeys });
-  for (const ws of connectedClients) {
-    try {
-      ws.send(invalidateMsg);
-    } catch {
-      connectedClients.delete(ws);
-    }
-  }
-}
 function handleWsMessage(ws, raw) {
   try {
     const msg = typeof raw === "string" ? JSON.parse(raw) : JSON.parse(raw.toString());
@@ -2075,7 +2107,6 @@ function crud(table, options) {
   });
   const createDef = !enabledMethods.has("create") ? void 0 : mutation(`${prefix}.create`, {
     public: isPublic,
-    invalidates: [],
     handler: async (ctx, args) => {
       const user = isPublic ? null : ctx.auth.requireAuth();
       let insertData = { ...args };
@@ -2095,7 +2126,6 @@ function crud(table, options) {
   });
   const updateDef = !enabledMethods.has("update") ? void 0 : mutation(`${prefix}.update`, {
     public: isPublic,
-    invalidates: [],
     handler: async (ctx, args) => {
       if (!isPublic) ctx.auth.requireAuth();
       const { id, ...updates } = args;
@@ -2121,7 +2151,6 @@ function crud(table, options) {
   });
   const removeDef = !enabledMethods.has("remove") ? void 0 : mutation(`${prefix}.remove`, {
     public: isPublic,
-    invalidates: [],
     handler: async (ctx, args) => {
       if (!isPublic) ctx.auth.requireAuth();
       if (options?.softDelete) {
@@ -2164,7 +2193,6 @@ export {
   getSchedulerInfo,
   handleWsMessage,
   httpAction,
-  invalidateQueries,
   mutation,
   ownerRls,
   parseArgs,