gencow 0.1.125 → 0.1.126

package/bin/gencow.mjs

@@ -677,6 +677,11 @@ function cleanupOldBackups(backupDir, keep = 3) {
     } catch { /* ignore */ }
 }
 
+function isLocalDbTarget(args) {
+    if (process.env.GENCOW_LOCAL === "1") return true;
+    return Array.isArray(args) && args.includes("--local");
+}
+
 // ─── Commands ─────────────────────────────────────────────
 
 const commands = {
@@ -783,8 +788,8 @@ const commands = {
             "@gencow/core": "latest",
             "@electric-sql/pglite": "^0.3.15",
             "better-auth": "^1.5.1",
-            "drizzle-orm": "^0.44.0",
-            "drizzle-kit": "^0.31.0",
+            "drizzle-orm": "^0.45.1",
+            "drizzle-kit": "^0.31.4",
             "postgres": "^3.4.8",
         };
         const pkgJsonPath = resolve(projectDir, "package.json");
@@ -1049,9 +1054,81 @@ ${hasPrompt ? `
     },
 
     // ── db:reset ─────────────────────────────────────────
-    async "db:reset"() {
-            info(`db:reset is ${BOLD}coming soon${RESET}.`);
-            info(`${DIM}Use Gencow Dashboard for cloud DB management.${RESET}\n`);
+    // TRUNCATE all user tables + seed.ts 실행.
+    // 로컬 전용: Cloud DB reset은 위험하므로 CLI에서 미지원 (Dashboard에서만 가능)
+    // 사용: gencow db:reset --local
+    async "db:reset"(...args) {
+            const config = loadConfig();
+            const cwd = process.cwd();
+            const isLocal = isLocalDbTarget(args);
+
+            if (!isLocal) {
+                error("db:reset only applies to the local database.");
+                info(`${DIM}Cloud DB reset is only available via Dashboard (data protection).${RESET}`);
+                info(`${DIM}For local DB: set ${GREEN}GENCOW_LOCAL=1${RESET}${DIM} and run this command again.${RESET}`);
+                log("");
+                return;
+            }
+
+            const port = process.env.PORT || config.port || 5456;
+
+            log(`\n${BOLD}${CYAN}Gencow DB Reset${RESET}\n`);
+
+            let serverAlive = false;
+            try {
+                const res = await fetch(`http://localhost:${port}/_admin/status`, { signal: AbortSignal.timeout(2000) });
+                serverAlive = res.ok;
+            } catch { /* 서버 꺼져있음 */ }
+
+            if (serverAlive) {
+                info(`Server detected on :${port} — using API reset (TRUNCATE + seed)`);
+                log("");
+
+                try {
+                    const res = await fetch(`http://localhost:${port}/_admin/reset`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ confirm: "delete all data" }),
+                    });
+                    const data = await res.json();
+
+                    if (!res.ok) {
+                        error(`Reset failed: ${data.error || "Unknown error"}`);
+                        log("");
+                        return;
+                    }
+
+                    success(`TRUNCATE done: ${data.truncated?.length || 0} tables`);
+                    if (data.truncated?.length > 0) {
+                        info(`  ${DIM}${data.truncated.join(", ")}${RESET}`);
+                    }
+                    if (data.seeded) {
+                        success(`Seed completed ✓`);
+                    } else {
+                        info(`${DIM}No seed.ts found — skipping${RESET}`);
+                    }
+                } catch (e) {
+                    error(`Server connection failed: ${e.message}`);
+                }
+            } else {
+                const dbPath = resolve(cwd, config.db.url);
+                if (existsSync(dbPath)) {
+                    const backupDir = resolve(cwd, ".gencow", "backups");
+                    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+                    const backupPath = resolve(backupDir, ts);
+                    mkdirSync(backupPath, { recursive: true });
+                    cpSync(dbPath, backupPath, { recursive: true });
+                    success(`Backup created: .gencow/backups/${ts}`);
+
+                    cleanupOldBackups(backupDir, 3);
+
+                    rmSync(dbPath, { recursive: true, force: true });
+                    success("DB deleted — restart with gencow dev:local to create a new one");
+                } else {
+                    info("DB does not exist yet. Run gencow dev:local to get started.");
+                }
+            }
+            log("");
         },
 
     // ── db:seed ──────────────────────────────────────────
@@ -1059,11 +1136,48 @@ ${hasPrompt ? `
     // Cloud-first: 기본=Cloud, --local=로컬
     async "db:seed"(...args) {
             const config = loadConfig();
-            const isLocal = args.includes("--local");
+            const isLocal = isLocalDbTarget(args);
 
             if (isLocal) {
-                info(`Local db:seed is ${BOLD}coming soon${RESET}.`);
-                info(`${DIM}Use cloud mode (default): gencow db:seed${RESET}\n`);
+                const port = process.env.PORT || config.port || 5456;
+
+                log(`\n${BOLD}${CYAN}Gencow DB Seed${RESET} ${DIM}(local)${RESET}\n`);
+
+                try {
+                    const statusRes = await fetch(`http://localhost:${port}/_admin/status`, { signal: AbortSignal.timeout(2000) });
+                    if (!statusRes.ok) throw new Error("Server not ready");
+                } catch {
+                    error(`Server not running on :${port}`);
+                    info(`${DIM}Start the local server first: ${GREEN}gencow dev:local${RESET}`);
+                    log("");
+                    return;
+                }
+
+                try {
+                    const res = await fetch(`http://localhost:${port}/_admin/seed`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                    });
+                    const data = await res.json();
+
+                    if (res.status === 404) {
+                        warn("gencow/seed.ts not found");
+                        info(`\n  ${DIM}Create gencow/seed.ts:${RESET}\n`);
+                        log(`  ${DIM}import { tasks } from "./schema";${RESET}`);
+                        log(`  ${DIM}export default async function seed(ctx) {${RESET}`);
+                        log(`  ${DIM}  await ctx.db.insert(tasks).values([${RESET}`);
+                        log(`  ${DIM}    { title: "Hello World" },${RESET}`);
+                        log(`  ${DIM}  ]);${RESET}`);
+                        log(`  ${DIM}};${RESET}`);
+                    } else if (!res.ok) {
+                        error(`Seed failed: ${data.error || "Unknown error"}`);
+                    } else {
+                        success("Seed completed ✓");
+                    }
+                } catch (e) {
+                    error(`Server connection failed: ${e.message}`);
+                }
+                log("");
                 return;
             }
 
@@ -1198,15 +1312,11 @@ ${hasPrompt ? `
             if (devArgs.includes("--verbose")) {
                 process.env.GENCOW_VERBOSE = "true";
             }
-            // --local 플래그: coming soon
-            if (devArgs.includes("--local")) {
-                log(`\n${BOLD}${CYAN}Gencow Dev${RESET} ${DIM}(local)${RESET}\n`);
-                info(`Local development mode is ${BOLD}coming soon${RESET}.`);
-                info(`${DIM}Use cloud mode (default): gencow dev${RESET}\n`);
-                return;
+            const useLocal = process.env.GENCOW_LOCAL === "1" || devArgs.includes("--local");
+            if (useLocal) {
+                const forwarded = devArgs.filter(a => a !== "--local");
+                return commands["dev:local"](...forwarded);
             }
-            // --cloud 하위 호환 (이미 기본이므로 그대로 진행)
-            // 기본 = 클라우드 모드
             return commands["dev:cloud"](...devArgs);
         },
 
@@ -1422,11 +1532,20 @@ ${hasPrompt ? `
     // Cloud-first: 기본=Cloud, --local=로컬
     async "db:push"(...args) {
             const config = loadConfig();
-            const isLocal = args.includes("--local");
+            const isLocal = isLocalDbTarget(args);
 
             if (isLocal) {
-                info(`Local db:push is ${BOLD}coming soon${RESET}.`);
-                info(`${DIM}Use cloud mode (default): gencow db:push${RESET}\n`);
+                let hasDb = !!process.env.DATABASE_URL;
+                if (!hasDb) {
+                    const envPath = resolve(process.cwd(), ".env");
+                    if (existsSync(envPath)) hasDb = readFileSync(envPath, "utf8").includes("DATABASE_URL=");
+                }
+                const targetDb = hasDb ? "local PG" : "local fallback: PGlite";
+                log(`\n${BOLD}${CYAN}Gencow DB Push${RESET} ${DIM}(${targetDb})${RESET}\n`);
+                info("Pushing schema.ts → database (no migration files)...");
+                runInServer("pnpm db:push --force", buildEnv(config));
+                success("Schema pushed!");
+                log(`  ${DIM}Tables are in sync with schema.ts${RESET}\n`);
                 return;
             }
 

package/core/index.js

@@ -1979,22 +1979,209 @@ function ownerRls(userIdColumn, options) {
 }
 
 // ../core/src/rls-db.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { sql as sql2 } from "drizzle-orm";
-function createRlsDb(db, userId) {
+var gucNameRe = /^app\.[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/;
+var RESERVED_VARS_KEYS = /* @__PURE__ */ new Set([
+  "app.current_user_id",
+  "app.current_user_role",
+  "app.tenant_id"
+]);
+function assertSafeGucName(key) {
+  if (!gucNameRe.test(key)) {
+    throw new Error(
+      `createRlsDb: GUC name "${key}" is invalid \u2014 use lowercase app.* names (e.g. app.org_id)`
+    );
+  }
+}
+function rlsSetConfigPairs(rls) {
+  const pairs = [["app.current_user_id", rls.userId]];
+  if (rls.role !== void 0) {
+    pairs.push(["app.current_user_role", rls.role]);
+  }
+  if (rls.tenantId !== void 0) {
+    pairs.push(["app.tenant_id", rls.tenantId]);
+  }
+  if (rls.vars) {
+    for (const [key, value] of Object.entries(rls.vars)) {
+      assertSafeGucName(key);
+      if (RESERVED_VARS_KEYS.has(key)) {
+        throw new Error(
+          `createRlsDb: vars must not set "${key}" \u2014 use userId, role, or tenantId on the context object`
+        );
+      }
+      pairs.push([key, value]);
+    }
+  }
+  return pairs;
+}
+async function forEachSetConfig(rls, setOne) {
+  for (const [name, value] of rlsSetConfigPairs(rls)) {
+    await setOne(name, value);
+  }
+}
+var rlsExecClient = new AsyncLocalStorage();
+function isDrizzleTransactionDb(db) {
+  const d = db;
+  if (typeof d?.rollback === "function") {
+    return true;
+  }
+  const name = d?.constructor?.name;
+  return typeof name === "string" && name.includes("Transaction");
+}
+async function execSetConfig(client, name, value) {
+  if (typeof client?.unsafe === "function") {
+    await client.unsafe(`select set_config($1::text, $2::text, true)`, [name, value]);
+    return;
+  }
+  if (typeof client?.query === "function") {
+    await client.query(`select set_config($1::text, $2::text, true)`, [name, value]);
+    return;
+  }
+  throw new Error(
+    "createRlsDb: unsupported SQL driver (expected Bun SQL, node-pg client/pool, or PGlite)"
+  );
+}
+async function applyRlsSessionVars(client, rls) {
+  await forEachSetConfig(rls, (name, value) => execSetConfig(client, name, value));
+}
+async function injectRlsVarsOnTx(tx, rls) {
+  await forEachSetConfig(
+    rls,
+    (name, value) => tx.execute(sql2`SELECT set_config(${name}, ${value}, true)`)
+  );
+}
+async function withRlsLeasedConnection(leased, rls, fn) {
+  try {
+    await leased.query("begin");
+    await applyRlsSessionVars(leased, rls);
+    const result = await rlsExecClient.run(leased, () => fn(leased));
+    await leased.query("commit");
+    return result;
+  } catch (e) {
+    try {
+      await leased.query("rollback");
+    } catch {
+    }
+    throw e;
+  } finally {
+    leased.release();
+  }
+}
+async function withRlsConnection(session, rls, reuseOuterConnection, fn) {
+  if (reuseOuterConnection) {
+    const c2 = session.client;
+    return rlsExecClient.run(c2, async () => {
+      await applyRlsSessionVars(c2, rls);
+      return fn(c2);
+    });
+  }
+  const c = session.client;
+  const runInner = async (client) => {
+    await applyRlsSessionVars(client, rls);
+    return rlsExecClient.run(client, () => fn(client));
+  };
+  if (typeof c.begin === "function") {
+    return c.begin(runInner);
+  }
+  if (typeof c.transaction === "function") {
+    return c.transaction(runInner);
+  }
+  if (typeof c.connect === "function" && typeof c.query === "function") {
+    const leased = await c.connect();
+    return withRlsLeasedConnection(leased, rls, fn);
+  }
+  return runInner(c);
+}
+function wrapPreparedQuery(pq, session, rls, reuseOuterConnection) {
+  const origExecute = pq.execute.bind(pq);
+  const origAll = pq.all.bind(pq);
+  pq.execute = async (placeholderValues) => {
+    const active = rlsExecClient.getStore();
+    if (active) {
+      const prev = pq.client;
+      pq.client = active;
+      try {
+        return await origExecute(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    }
+    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+      const prev = pq.client;
+      pq.client = client;
+      try {
+        return await origExecute(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    });
+  };
+  pq.all = async (placeholderValues) => {
+    const active = rlsExecClient.getStore();
+    if (active) {
+      const prev = pq.client;
+      pq.client = active;
+      try {
+        return await origAll(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    }
+    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+      const prev = pq.client;
+      pq.client = client;
+      try {
+        return await origAll(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    });
+  };
+}
+function wrapSession(session, rls, reuseOuterConnection) {
+  return new Proxy(session, {
+    get(sTarget, sProp, sRecv) {
+      if (sProp === "prepareQuery") {
+        return (...args) => {
+          const pq = sTarget.prepareQuery(...args);
+          wrapPreparedQuery(pq, sTarget, rls, reuseOuterConnection);
+          return pq;
+        };
+      }
+      const v2 = Reflect.get(sTarget, sProp, sRecv);
+      return typeof v2 === "function" ? v2.bind(sTarget) : v2;
+    }
+  });
+}
+function createRlsDb(db, rls) {
+  const reuseOuterConnection = isDrizzleTransactionDb(db);
+  const baseSession = db.session;
+  const wrappedSession = wrapSession(baseSession, rls, reuseOuterConnection);
   return new Proxy(db, {
     get(target, prop, receiver) {
+      if (prop === "session") {
+        return wrappedSession;
+      }
+      if (prop === "_") {
+        const inner = target._;
+        return new Proxy(inner, {
+          get(i, p, r) {
+            if (p === "session") return wrappedSession;
+            return Reflect.get(i, p, r);
+          }
+        });
+      }
       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)`
-            );
+            await injectRlsVarsOnTx(tx, rls);
             return await callback(tx);
           }, ...rest);
         };
       }
       const value = Reflect.get(target, prop, receiver);
-      return typeof value === "function" ? value.bind(target) : value;
+      return typeof value === "function" ? value.bind(receiver) : value;
     }
   });
 }