gencow 0.1.92 → 0.1.94

package/bin/gencow.mjs

@@ -296,10 +296,56 @@ process.exit(0);
     try {
         writeFileSync(extractTsPath, script);
 
-        const outStr = execSync(`bun .gencow-extract.ts`, {
-            cwd: serverRoot,
-            stdio: ["pipe", "pipe", "ignore"]
-        }).toString();
+        let outStr;
+        try {
+            outStr = execSync(`bun .gencow-extract.ts`, {
+                cwd: serverRoot,
+                stdio: ["pipe", "pipe", "pipe"]  // stderr도 캡처
+            }).toString();
+        } catch (execError) {
+            // bun 실행 자체가 실패한 경우 — stderr에서 구체적 원인 추출
+            const stderr = execError.stderr?.toString() || "";
+            const stdout = execError.stdout?.toString() || "";
+
+            error("API Codegen failed — gencow/index.ts를 파싱할 수 없습니다.");
+            log("");
+
+            // stderr에서 핵심 에러 줄 추출 (타입 에러, import 에러 등)
+            const errorLines = stderr.split("\n").filter(line =>
+                line.includes("error:") ||
+                line.includes("Error:") ||
+                line.includes("Cannot find") ||
+                line.includes("is not assignable") ||
+                line.includes("does not exist") ||
+                line.includes("Module not found")
+            ).slice(0, 5);  // 최대 5줄
+
+            if (errorLines.length > 0) {
+                error("원인:");
+                for (const line of errorLines) {
+                    info(`  ${RED}${line.trim()}${RESET}`);
+                }
+            } else if (stderr.trim()) {
+                // 패턴 매칭 안 되면 stderr 처음 3줄 출력
+                const firstLines = stderr.trim().split("\n").slice(0, 3);
+                for (const line of firstLines) {
+                    info(`  ${DIM}${line}${RESET}`);
+                }
+            }
+
+            log("");
+            info(`${YELLOW}해결 방법:${RESET}`);
+            info("  1. gencow/index.ts에서 TypeScript 에러를 수정하세요");
+            info("  2. import 경로가 올바른지 확인하세요");
+            info("  3. @gencow/core 패키지가 설치되어 있는지 확인하세요");
+            log("");
+
+            // 빈 스텁 api.ts 생성 — IDE가 즉시 에러를 잡을 수 있도록
+            const stubContent = `/**\n * ⚠️ API Codegen Failed\n *\n * gencow/index.ts에서 에러가 발생하여 api.ts를 생성할 수 없었습니다.\n * 콘솔의 에러 메시지를 확인하고 수정한 후 gencow dev를 재시작하세요.\n *\n * 이 파일은 자동 생성됩니다 — 직접 수정하지 마세요.\n */\nexport const api = {} as const;\n`;
+            writeFileSync(apiTsPath, stubContent);
+            warn(`빈 스텁 ${config.functionsDir}/api.ts 생성됨 (에러 수정 후 자동 재생성)`);
+            return;  // 에러를 throw하지 않고 조용히 반환 — dev 서버는 계속 실행
+        }
 
         const match = outStr.match(/GENCOW_API_JSON=({.*})/);
         if (!match) throw new Error("Could not parse registry output");
@@ -382,7 +428,11 @@ process.exit(0);
 
 
     } catch (e) {
-        warn(`API Codegen failed: ${e.message}`);
+        error(`API Codegen failed: ${e.message}`);
+        // 빈 스텁 api.ts 생성 — 예기치 않은 에러에서도 IDE가 즉시 에러를 잡을 수 있도록
+        const stubContent = `/**\n * ⚠️ API Codegen Failed: ${e.message.replace(/\*/g, "")}\n *\n * 에러를 수정한 후 gencow dev를 재시작하세요.\n * 이 파일은 자동 생성됩니다 — 직접 수정하지 마세요.\n */\nexport const api = {} as const;\n`;
+        try { writeFileSync(apiTsPath, stubContent); } catch { /* ignore */ }
+        warn(`빈 스텁 ${config.functionsDir}/api.ts 생성됨`);
     } finally {
         try { unlinkSync(extractTsPath); } catch { }
     }
@@ -726,7 +776,7 @@ export default defineConfig({
         if (existsSync(envPath) && force) {
             info(".env 이미 존재 — 건너뜁니다.");
         } else {
-            const envContent = `# Gencow Environment Variables\n# Add your environment variables here\n`;
+            const envContent = `# Gencow Environment Variables\n# Add your environment variables here\n\n# AI 기능 사용 시 필수 (ctx.ai.chat, ai.chat 등)\n# https://platform.openai.com/api-keys 에서 발급\nOPENAI_API_KEY=sk-your-key-here\n`;
             writeFileSync(envPath, envContent);
             success("Created .env");
         }
@@ -1359,7 +1409,7 @@ ${hasPrompt ? `
 
             // tar.gz 생성: gencow/ 폴더 전체 (schema.ts + import된 파일들)
             execSync(
-                `tar -czf "${tmpBundle}" -C "${process.cwd()}" "${functionsDir.replace(/^\.\//,'')}/"`,
+                `COPYFILE_DISABLE=1 tar -czf "${tmpBundle}" -C "${process.cwd()}" "${functionsDir.replace(/^\.\//,'')}/"`,
                 { stdio: ["ignore", "pipe", "pipe"] }
             );
 
@@ -1941,10 +1991,10 @@ ${BOLD}Examples:${RESET}
                             exec(`cp "${src}" "${dst}"`, { cwd: process.cwd() });
                         }
                     }
-                    exec(`tar -czf "${tmpBundle}" .`, { cwd: tmpDir });
+                    exec(`COPYFILE_DISABLE=1 tar -czf "${tmpBundle}" .`, { cwd: tmpDir });
                     exec(`rm -rf "${tmpDir}"`, { cwd: process.cwd() });
                 } else {
-                    exec(`tar -czf "${tmpBundle}" ${filesToPack.join(" ")}`, { cwd: process.cwd() });
+                    exec(`COPYFILE_DISABLE=1 tar -czf "${tmpBundle}" ${filesToPack.join(" ")}`, { cwd: process.cwd() });
                 }
             } catch (e) {
                 error(`패키징 실패: ${e.message}`);
@@ -2046,7 +2096,7 @@ ${BOLD}Examples:${RESET}
 
                     // 재배포
                     info("재배포 시도...");
-                    exec(`tar -czf "${tmpBundle}" ${filesToPack.join(" ")}`, { cwd: process.cwd() });
+                    exec(`COPYFILE_DISABLE=1 tar -czf "${tmpBundle}" ${filesToPack.join(" ")}`, { cwd: process.cwd() });
                     const retryBuffer = readFileSync(tmpBundle);
 
                     const retryStartTime = Date.now();
@@ -2217,7 +2267,44 @@ ${BOLD}Examples:${RESET}
                 && (existsSync(resolve(parentDir, "gencow.config.ts")) || existsSync(resolve(parentDir, "package.json")));
             const detectedBackend = hasCwdBackend || hasParentBackend;
             const backendRoot = hasCwdBackend ? process.cwd() : (hasParentBackend ? parentDir : null);
-            const shouldDeployBackend = detectedBackend && !noBackend;
+
+            // ── 빈 백엔드 자동 감지: gencow/ 내 query/mutation/httpAction 호출이 없으면 skip ──
+            // schema.ts + 빈 API 파일만 있는 경우에도 올바르게 감지
+            let isBackendEmpty = false;
+            if (detectedBackend && backendRoot) {
+                const gencowDir = resolve(backendRoot, "gencow");
+                try {
+                    const scanTsFiles = (dir) => {
+                        const entries = readdirSync(dir, { withFileTypes: true });
+                        const files = [];
+                        for (const e of entries) {
+                            const p = resolve(dir, e.name);
+                            if (e.isDirectory() && e.name !== "node_modules") files.push(...scanTsFiles(p));
+                            else if (e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx"))) files.push(p);
+                        }
+                        return files;
+                    };
+                    const tsFiles = scanTsFiles(gencowDir);
+                    // query(, mutation(, httpAction( 호출이 하나라도 있으면 실질적 백엔드
+                    const hasApiCalls = tsFiles.some(f => {
+                        const src = readFileSync(f, "utf8");
+                        return /\b(query|mutation|httpAction)\s*\(/.test(src);
+                    });
+                    if (!hasApiCalls) {
+                        isBackendEmpty = true;
+                    }
+                } catch {
+                    // 스캔 실패 시 안전하게 백엔드 있다고 가정
+                    isBackendEmpty = false;
+                }
+            }
+
+            const shouldDeployBackend = detectedBackend && !noBackend && !isBackendEmpty;
+
+            if (isBackendEmpty && detectedBackend) {
+                info(`${DIM}gencow/ 감지됨 — API 함수(query/mutation) 없음 → 백엔드 배포 건너뜀${RESET}`);
+                info(`${DIM}💡 백엔드가 필요하면 gencow/ 내 .ts 파일에 query() 또는 mutation()을 정의하세요.${RESET}`);
+            }
 
             if (shouldDeployBackend) {
                 log(`\n${BOLD}${CYAN}Gencow Deploy (Fullstack)${RESET}\n`);
@@ -2358,10 +2445,10 @@ ${BOLD}Examples:${RESET}
                                 exec(`cp "${src}" "${dst}"`, { cwd: backendRoot });
                             }
                         }
-                        exec(`tar -czf "${tmpBackendBundle}" .`, { cwd: tmpDir });
+                        exec(`COPYFILE_DISABLE=1 tar -czf "${tmpBackendBundle}" .`, { cwd: tmpDir });
                         exec(`rm -rf "${tmpDir}"`, { cwd: backendRoot });
                     } else {
-                        exec(`tar -czf "${tmpBackendBundle}" ${backendFiles.join(" ")}`, { cwd: backendRoot });
+                        exec(`COPYFILE_DISABLE=1 tar -czf "${tmpBackendBundle}" ${backendFiles.join(" ")}`, { cwd: backendRoot });
                     }
                 } catch (e) {
                     error(`백엔드 패키징 실패: ${e.message}`);
@@ -2452,7 +2539,7 @@ ${BOLD}Examples:${RESET}
             mkdirSync(dirname(tmpBundle), { recursive: true });
 
             try {
-                exec(`tar -czf "${tmpBundle}" -C "${resolve(process.cwd(), targetDir)}" .`, { cwd: process.cwd() });
+                exec(`COPYFILE_DISABLE=1 tar -czf "${tmpBundle}" -C "${resolve(process.cwd(), targetDir)}" .`, { cwd: process.cwd() });
             } catch (e) {
                 error(`패키징 실패: ${e.message}`);
                 process.exit(1);
@@ -3366,56 +3453,90 @@ process.exit(0);
                 return;
             }
 
-            // ── Follow 모드: WebSocket 실시간 스트리밍 ──
+            // ── Follow 모드: WebSocket 실시간 스트리밍 (지수 백오프 재연결) ──
             const config = loadConfig();
             const port = process.env.PORT || config.port || 5456;
-            const wsUrl = `ws://localhost:${port}/ws`;
 
             log(`\n${BOLD}${CYAN}Gencow Logs${RESET}  ${DIM}— streaming (Ctrl+C to stop)${RESET}\n`);
-            info(`Connecting to ${DIM}${wsUrl}${RESET}...`);
 
-            const { WebSocket: WS } = await import("ws");
-            const ws = new WS(wsUrl);
+            const FOLLOW_BASE_RECONNECT_MS = 3000;
+            const FOLLOW_MAX_RECONNECT_MS = 30000;
+            const FOLLOW_MAX_FAILURES = 5;
+            let followFailures = 0;
+            let followTimer = null;
+            let followWs = null;
 
-            ws.on("open", () => {
-                success("Connected — streaming logs...\n");
-                ws.send(JSON.stringify({ type: "log:subscribe" }));
-            });
+            async function connectFollowStream() {
+                const wsUrl = `ws://localhost:${port}/ws`;
+                info(`Connecting to ${DIM}${wsUrl}${RESET}...`);
 
-            ws.on("message", (raw) => {
+                const { WebSocket: WS } = await import("ws");
                 try {
-                    const msg = JSON.parse(raw.toString());
+                    followWs = new WS(wsUrl);
+                } catch (e) {
+                    error(`WebSocket error: ${e.message}`);
+                    scheduleFollowReconnect();
+                    return;
+                }
 
-                    if (msg.type === "log:subscribed") {
-                        return; // 구독 확인 — 무시
-                    }
+                followWs.on("open", () => {
+                    followFailures = 0;  // 성공 → 실패 카운터 리셋
+                    success("Connected — streaming logs...\n");
+                    followWs.send(JSON.stringify({ type: "log:subscribe" }));
+                });
 
-                    if (msg.type === "log:entry") {
-                        const ts = msg.timestamp?.slice(11, 19) || "";
-                        const lvl = msg.level === "error" ? `${RED}ERR${RESET}`
-                            : msg.level === "warn" ? `${YELLOW}WRN${RESET}`
-                                : `${DIM}INF${RESET}`;
-                        const src = msg.source ? ` ${DIM}[${msg.source}]${RESET}` : "";
-                        log(`  ${DIM}${ts}${RESET} ${lvl}${src} ${msg.message}`);
+                followWs.on("message", (raw) => {
+                    try {
+                        const msg = JSON.parse(raw.toString());
+
+                        if (msg.type === "log:subscribed") {
+                            return; // 구독 확인 — 무시
+                        }
+
+                        if (msg.type === "log:entry") {
+                            const ts = msg.timestamp?.slice(11, 19) || "";
+                            const lvl = msg.level === "error" ? `${RED}ERR${RESET}`
+                                : msg.level === "warn" ? `${YELLOW}WRN${RESET}`
+                                    : `${DIM}INF${RESET}`;
+                            const src = msg.source ? ` ${DIM}[${msg.source}]${RESET}` : "";
+                            log(`  ${DIM}${ts}${RESET} ${lvl}${src} ${msg.message}`);
+                        }
+                    } catch { /* ignore non-JSON */ }
+                });
+
+                followWs.on("error", () => {
+                    // 에러는 close 이벤트로 처리
+                });
+
+                followWs.on("close", () => {
+                    followFailures++;
+                    if (followFailures > FOLLOW_MAX_FAILURES) {
+                        error(`연결 불가 — 앱 상태를 확인하세요.`);
+                        info(`서버가 실행 중인지 확인: gencow dev`);
+                        process.exit(1);
                     }
-                } catch { /* ignore non-JSON */ }
-            });
+                    const delay = Math.min(FOLLOW_BASE_RECONNECT_MS * Math.pow(2, followFailures - 1), FOLLOW_MAX_RECONNECT_MS);
+                    const delaySec = (delay / 1000).toFixed(0);
+                    warn(`연결 끊김 — ${delaySec}초 후 재연결... (${followFailures}/${FOLLOW_MAX_FAILURES})`);
+                    scheduleFollowReconnect(delay);
+                });
+            }
 
-            ws.on("error", (e) => {
-                error(`WebSocket error: ${e.message}`);
-                info(`Make sure the server is running (gencow dev)`);
-                process.exit(1);
-            });
+            function scheduleFollowReconnect(delayMs = FOLLOW_BASE_RECONNECT_MS) {
+                if (followTimer) return;
+                followTimer = setTimeout(() => {
+                    followTimer = null;
+                    connectFollowStream().catch(() => { });
+                }, delayMs);
+            }
 
-            ws.on("close", () => {
-                log(`\n${DIM}  Connection closed.${RESET}\n`);
-                process.exit(0);
-            });
+            connectFollowStream().catch(() => { });
 
             // Ctrl+C 처리
             process.on("SIGINT", () => {
                 log(`\n\n${DIM}  Stopped streaming.${RESET}\n`);
-                ws.close();
+                if (followWs) followWs.close();
+                if (followTimer) clearTimeout(followTimer);
                 process.exit(0);
             });
         },
@@ -3838,7 +3959,7 @@ process.exit(0);
 
             // 지수 백오프 재연결 상수
             const BASE_RECONNECT_MS = 3000;
-            const MAX_RECONNECT_MS = 60000;
+            const MAX_RECONNECT_MS = 30000;  // 30s cap (기존 60s → 30s로 축소)
             const MAX_RECONNECT_FAILURES = 5;
             let reconnectFailures = 0;
 

package/core/index.js

@@ -1880,131 +1880,188 @@ function ownerRls(userIdColumn, options) {
 // ../core/src/rls-db.ts
 import { sql as sql2 } from "drizzle-orm";
 function createRlsDb(db, userId) {
-  return {
-    ...db,
-    transaction: (async (callback, ...rest) => {
-      return await db.transaction(async (tx) => {
-        await tx.execute(
-          sql2`SELECT set_config('app.current_user_id', ${userId}, true)`
-        );
-        return await callback(tx);
-      }, ...rest);
-    })
-  };
+  return new Proxy(db, {
+    get(target, prop, receiver) {
+      if (prop === "transaction") {
+        return async (callback, ...rest) => {
+          return await target.transaction(async (tx) => {
+            await tx.execute(
+              sql2`SELECT set_config('app.current_user_id', ${userId}, true)`
+            );
+            return await callback(tx);
+          }, ...rest);
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
 }
 
 // ../core/src/crud.ts
-import { eq, or, and, ilike, desc, asc, inArray, count, sql as sql3 } from "drizzle-orm";
-function gencowCrud(db) {
-  return function createCrud(table, options) {
-    const anyTable = table;
-    const pk = anyTable["id"];
-    if (!pk) {
-      throw new Error(`[gencowCrud] Table ${anyTable["_"]["name"]} must have an 'id' column.`);
+import { eq, desc, asc, ilike, or, and, count as drizzleCount, getTableName } from "drizzle-orm";
+function detectIdType(column) {
+  const colType = column.dataType;
+  if (colType === "string") return v.string();
+  return v.number();
+}
+function crud(table, options) {
+  const anyTable = table;
+  const tableName = getTableName(table);
+  const prefix = options?.prefix || tableName;
+  const isPublic = options?.public ?? false;
+  const useRealtime = options?.realtime ?? true;
+  const defaultLimit = options?.defaultLimit ?? 20;
+  const maxLimit = options?.maxLimit ?? 100;
+  const pk = anyTable["id"];
+  if (!pk) {
+    throw new Error(`[crud] Table "${tableName}" must have an 'id' column.`);
+  }
+  const idValidator = detectIdType(pk);
+  const createdAtCol = anyTable["createdAt"];
+  const defaultOrderCol = createdAtCol || pk;
+  const userIdCol = anyTable["userId"];
+  function buildWhereConditions(args) {
+    const conditions = [];
+    if (options?.softDelete) {
+      const sdField = anyTable[options.softDelete.field];
+      conditions.push(eq(sdField, null));
     }
-    async function create(data) {
-      let insertData = { ...data };
-      if (options?.hooks?.beforeCreate) {
-        insertData = await options.hooks.beforeCreate(insertData);
-      }
-      const [result] = await db.insert(anyTable).values(insertData).returning();
-      return result;
+    if (args?.search && options?.searchFields?.length) {
+      const searchConds = options.searchFields.map(
+        (f) => ilike(anyTable[f], `%${args.search}%`)
+      );
+      conditions.push(or(...searchConds));
     }
-    async function findById(id) {
-      let whereCond = eq(pk, id);
-      if (options?.softDelete) {
-        const sdField = anyTable[options.softDelete.field];
-        whereCond = and(whereCond, sql3`${sdField} IS NULL`);
+    if (args?.filters && options?.allowedFilters?.length) {
+      for (const [key, value] of Object.entries(args.filters)) {
+        if (options.allowedFilters.includes(key) && anyTable[key]) {
+          conditions.push(eq(anyTable[key], value));
+        }
       }
-      const [result] = await db.select().from(anyTable).where(whereCond).limit(1);
-      return result || null;
     }
-    async function list(params) {
-      const page = Math.max(1, params?.page || 1);
-      const limit = Math.min(
-        Math.max(1, params?.limit || options?.defaultLimit || 20),
-        options?.maxLimit || 100
-      );
+    return conditions.length > 0 ? and(...conditions) : void 0;
+  }
+  async function fetchListWithTotal(db, whereClause) {
+    const [data, countResult] = await Promise.all([
+      db.select().from(anyTable).where(whereClause).orderBy(desc(defaultOrderCol)),
+      db.select({ count: drizzleCount() }).from(anyTable).where(whereClause)
+    ]);
+    return { data, total: Number(countResult[0]?.count ?? 0) };
+  }
+  const listDef = query(`${prefix}.list`, {
+    public: isPublic,
+    args: {
+      page: v.optional(v.number()),
+      limit: v.optional(v.number()),
+      search: v.optional(v.string()),
+      orderBy: v.optional(v.string()),
+      orderDir: v.optional(v.string()),
+      filters: v.optional(v.any())
+    },
+    handler: async (ctx, args) => {
+      if (!isPublic) ctx.auth.requireAuth();
+      const page = Math.max(1, args?.page || 1);
+      const limit = Math.min(Math.max(1, args?.limit || defaultLimit), maxLimit);
       const offset = (page - 1) * limit;
-      const conditions = [];
-      if (options?.softDelete && !params?.includeDeleted) {
-        conditions.push(sql3`${anyTable[options.softDelete.field]} IS NULL`);
-      }
-      if (params?.search && options?.searchFields?.length) {
-        const searchConds = options.searchFields.map(
-          (f) => ilike(anyTable[f], `%${params.search}%`)
-        );
-        conditions.push(or(...searchConds));
-      }
-      if (params?.filters && options?.allowedFilters) {
-        for (const [k, v2] of Object.entries(params.filters)) {
-          if (options.allowedFilters.includes(k)) {
-            conditions.push(eq(anyTable[k], v2));
-          }
-        }
+      const whereClause = buildWhereConditions(args);
+      let orderByClause;
+      if (args?.orderBy && anyTable[args.orderBy]) {
+        const col = anyTable[args.orderBy];
+        orderByClause = args.orderDir === "asc" ? asc(col) : desc(col);
+      } else {
+        orderByClause = desc(defaultOrderCol);
       }
-      const whereClause = conditions.length > 0 ? and(...conditions) : void 0;
-      const orderByArgs = (params?.orderBy || []).map((o) => {
-        const col = anyTable[o.field];
-        return o.direction === "desc" ? desc(col) : asc(col);
-      });
-      const [{ count: total }] = await db.select({ count: count() }).from(anyTable).where(whereClause);
-      const results = await db.select().from(anyTable).where(whereClause).orderBy(...orderByArgs).limit(limit).offset(offset);
+      const [results, countResult] = await Promise.all([
+        ctx.db.select().from(anyTable).where(whereClause).orderBy(orderByClause).limit(limit).offset(offset),
+        ctx.db.select({ count: drizzleCount() }).from(anyTable).where(whereClause)
+      ]);
       return {
-        results,
-        page,
-        limit,
-        total: Number(total)
+        data: results,
+        total: Number(countResult[0]?.count ?? 0)
       };
     }
-    async function update(id, data) {
-      let updateData = { ...data };
-      if (options?.hooks?.beforeUpdate) {
-        updateData = await options.hooks.beforeUpdate(updateData);
-      }
-      const [result] = await db.update(anyTable).set(updateData).where(eq(pk, id)).returning();
-      return result;
-    }
-    async function deleteOne(id) {
+  });
+  const getDef = query(`${prefix}.get`, {
+    public: isPublic,
+    args: { id: idValidator },
+    handler: async (ctx, args) => {
+      if (!isPublic) ctx.auth.requireAuth();
+      let whereCond = eq(pk, args.id);
       if (options?.softDelete) {
-        const sdField = options.softDelete.field;
-        await db.update(anyTable).set({ [sdField]: /* @__PURE__ */ new Date() }).where(eq(pk, id));
-      } else {
-        await db.delete(anyTable).where(eq(pk, id));
+        const sdField = anyTable[options.softDelete.field];
+        whereCond = and(whereCond, eq(sdField, null));
       }
+      const [result] = await ctx.db.select().from(anyTable).where(whereCond).limit(1);
+      return result ?? null;
     }
-    async function restore(id) {
-      if (options?.softDelete) {
-        const sdField = options.softDelete.field;
-        await db.update(anyTable).set({ [sdField]: null }).where(eq(pk, id));
+  });
+  const createDef = mutation(`${prefix}.create`, {
+    public: isPublic,
+    invalidates: [],
+    handler: async (ctx, args) => {
+      const user = isPublic ? null : ctx.auth.requireAuth();
+      let insertData = { ...args };
+      if (userIdCol && user && !insertData.userId) {
+        insertData.userId = user.id;
       }
-    }
-    async function bulkCreate(dataArray) {
-      let insertData = [...dataArray];
       if (options?.hooks?.beforeCreate) {
-        insertData = await Promise.all(insertData.map((d) => options.hooks.beforeCreate(d)));
+        insertData = await options.hooks.beforeCreate(insertData);
+      }
+      const [result] = await ctx.db.insert(anyTable).values(insertData).returning();
+      if (useRealtime) {
+        const listResult = await fetchListWithTotal(ctx.db);
+        ctx.realtime.emit(`${prefix}.list`, listResult);
       }
-      return await db.insert(anyTable).values(insertData).returning();
+      return result;
+    }
+  });
+  const updateDef = mutation(`${prefix}.update`, {
+    public: isPublic,
+    invalidates: [],
+    handler: async (ctx, args) => {
+      if (!isPublic) ctx.auth.requireAuth();
+      const { id, ...updates } = args;
+      let updateData = { ...updates };
+      if (anyTable["updatedAt"]) {
+        updateData.updatedAt = /* @__PURE__ */ new Date();
+      }
+      if (options?.hooks?.beforeUpdate) {
+        updateData = await options.hooks.beforeUpdate(updateData);
+      }
+      const [result] = await ctx.db.update(anyTable).set(updateData).where(eq(pk, id)).returning();
+      if (useRealtime) {
+        const listResult = await fetchListWithTotal(ctx.db);
+        ctx.realtime.emit(`${prefix}.list`, listResult);
+        ctx.realtime.emit(`${prefix}.get`, result);
+      }
+      return result;
     }
-    async function bulkDelete(ids) {
-      if (ids.length === 0) return;
+  });
+  const removeDef = mutation(`${prefix}.remove`, {
+    public: isPublic,
+    invalidates: [],
+    handler: async (ctx, args) => {
+      if (!isPublic) ctx.auth.requireAuth();
       if (options?.softDelete) {
         const sdField = options.softDelete.field;
-        await db.update(anyTable).set({ [sdField]: /* @__PURE__ */ new Date() }).where(inArray(pk, ids));
+        await ctx.db.update(anyTable).set({ [sdField]: /* @__PURE__ */ new Date() }).where(eq(pk, args.id));
       } else {
-        await db.delete(anyTable).where(inArray(pk, ids));
+        await ctx.db.delete(anyTable).where(eq(pk, args.id));
+      }
+      if (useRealtime) {
+        const listResult = await fetchListWithTotal(ctx.db);
+        ctx.realtime.emit(`${prefix}.list`, listResult);
       }
+      return { success: true };
     }
-    return {
-      create,
-      findById,
-      list,
-      update,
-      deleteOne,
-      restore,
-      bulkCreate,
-      bulkDelete
-    };
+  });
+  return {
+    list: listDef,
+    get: getDef,
+    create: createDef,
+    update: updateDef,
+    remove: removeDef
   };
 }
 export {
@@ -2013,9 +2070,10 @@ export {
   createRlsDb,
   createScheduler,
   cronJobs,
+  crud,
   defineAuth,
   deregisterClient,
-  gencowCrud,
+  crud as gencowCrud,
   getQueryDef,
   getQueryHandler,
   getRegisteredHttpActions,