gencow 0.1.141 → 0.1.142

package/bin/gencow.mjs

@@ -81,7 +81,7 @@ import {
 import { platformFetch, requireCreds, rpcMutation, rpcQuery } from "../lib/platform-client.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const _drizzleKitCmd = (subcmd) => buildDrizzleKitCommand(subcmd);
+const _drizzleKitCmd = (subcmd, options = {}) => buildDrizzleKitCommand(subcmd, options);
 const generateApiTs = createApiCodegenRuntime({});
 const runAddCommand = createAddCommand({
   loadConfig,
@@ -197,6 +197,12 @@ const { dev: runDevCommand, devLocal: runDevLocalCommand } = createDevLocalComma
 });
 const runConfigCommand = createConfigCommand();
 const runCorsCommand = createCorsCommand();
+const runStaticDeployRuntime = createStaticDeployRuntime({
+  cwdImpl: () => process.cwd(),
+  drizzleKitCmdImpl: _drizzleKitCmd,
+  verifyAppReadyImpl: verifyAppReady,
+  updateEnvLocalUrlImpl: updateEnvLocalUrl,
+});
 const runDeployCommand = createDeployCommand({
   cwdImpl: () => process.cwd(),
   drizzleKitCmdImpl: _drizzleKitCmd,
@@ -213,6 +219,7 @@ const runDeployCommand = createDeployCommand({
   resolvePathImpl: resolve,
   rpcMutationImpl: rpcMutation,
   rpcQueryImpl: rpcQuery,
+  runStaticDeployRuntimeImpl: runStaticDeployRuntime,
   setTimeoutImpl: setTimeout,
   unlinkSyncImpl: unlinkSync,
   verifyAppReadyImpl: verifyAppReady,
@@ -225,12 +232,6 @@ const runFilesCommand = createFilesCommand();
 const runInitCommand = createInitCommand();
 const runJobsCommand = createJobsCommand();
 const runLogsCommand = createLogsCommand({ loadConfig });
-const runStaticDeployRuntime = createStaticDeployRuntime({
-  cwdImpl: () => process.cwd(),
-  drizzleKitCmdImpl: _drizzleKitCmd,
-  verifyAppReadyImpl: verifyAppReady,
-  updateEnvLocalUrlImpl: updateEnvLocalUrl,
-});
 const runStaticCommand = createStaticCommand({
   cwdImpl: () => process.cwd(),
   requireCredsImpl: requireCreds,
@@ -304,7 +305,7 @@ ${BOLD}Commands (login required):${RESET}
   ${GREEN}db:generate${RESET}      Generate SQL migration files from schema.ts
   ${GREEN}db:seed${RESET}          Run gencow/seed.ts on cloud app
                      ${DIM}--prod      Seed production app${RESET}
-  ${GREEN}static [dir]${RESET}     Deploy static files ${DIM}(dist/, out/, build/)${RESET}
+  ${GREEN}static [dir]${RESET}     Deploy static files only ${DIM}(dist/, out/, build/)${RESET}
                      ${DIM}--prod          Deploy to production app${RESET}
                      ${DIM}--force, -f     Skip optional dependency scan${RESET}
   ${GREEN}templates publish${RESET} Publish current project as a marketplace template
@@ -312,6 +313,8 @@ ${BOLD}Commands (login required):${RESET}
   ${GREEN}templates list${RESET}    Browse public templates
   ${GREEN}templates clone <slug>${RESET} Clone a template into a local directory
   ${GREEN}deploy${RESET}           Deploy backend to cloud ${DIM}(dev by default)${RESET}
+                     ${DIM}--static [dir]  Deploy backend, then static files${RESET}
+                     ${DIM}--no-backend    With --static, skip backend deployment${RESET}
                      ${DIM}--prod          Deploy to production (Pro+ only)${RESET}
                      ${DIM}--rollback      Rollback to previous deployment${RESET}
                      ${DIM}--force, -f     Skip optional dependency scan${RESET}
@@ -362,6 +365,9 @@ ${BOLD}Examples:${RESET}
   ${DIM}# Deploy to dev:${RESET}
   gencow deploy
 
+  ${DIM}# Deploy backend + built frontend:${RESET}
+  gencow deploy --static dist/
+
   ${DIM}# Deploy to production (Pro+ only):${RESET}
   gencow deploy --prod
 

package/core/index.js

@@ -1585,15 +1585,37 @@ var ragOperationMetrics = pgTable("rag_operation_metrics", {
   recordedAt: timestamp("recorded_at").defaultNow().notNull()
 });
 
-// ../core/src/reactive.ts
+// ../core/src/reactive-query.ts
 if (!globalThis.__gencow_queryRegistry) globalThis.__gencow_queryRegistry = /* @__PURE__ */ new Map();
-if (!globalThis.__gencow_mutationRegistry) globalThis.__gencow_mutationRegistry = [];
+var queryRegistry = globalThis.__gencow_queryRegistry;
+function query(key, handlerOrDef) {
+  let handler;
+  let argsSchema;
+  let isPublic = false;
+  if (typeof handlerOrDef === "function") {
+    handler = handlerOrDef;
+  } else {
+    handler = handlerOrDef.handler;
+    argsSchema = handlerOrDef.args;
+    isPublic = handlerOrDef.public === true;
+  }
+  const def = { key, handler, argsSchema, isPublic };
+  queryRegistry.set(key, def);
+  return def;
+}
+function getQueryHandler(key) {
+  return queryRegistry.get(key)?.handler;
+}
+function getQueryDef(key) {
+  return queryRegistry.get(key);
+}
+function getRegisteredQueries() {
+  return Array.from(queryRegistry.keys());
+}
+
+// ../core/src/reactive-realtime.ts
 if (!globalThis.__gencow_subscribers) globalThis.__gencow_subscribers = /* @__PURE__ */ new Map();
 if (!globalThis.__gencow_connectedClients) globalThis.__gencow_connectedClients = /* @__PURE__ */ new Set();
-if (!globalThis.__gencow_httpActionRegistry) globalThis.__gencow_httpActionRegistry = [];
-var queryRegistry = globalThis.__gencow_queryRegistry;
-var mutationRegistry = globalThis.__gencow_mutationRegistry;
-var httpActionRegistry = globalThis.__gencow_httpActionRegistry;
 var subscribers = globalThis.__gencow_subscribers;
 var connectedClients = globalThis.__gencow_connectedClients;
 var SUBSCRIPTION_KEY_SEPARATOR = "::";
@@ -1624,69 +1646,6 @@ function buildQuerySubscriptionKey(queryKey, args) {
 function subscriptionKeyMatchesQueryKey(subscriptionKey, queryKey) {
   return subscriptionKey === queryKey || subscriptionKey.startsWith(`${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}`);
 }
-function query(key, handlerOrDef) {
-  let handler;
-  let argsSchema;
-  let isPublic = false;
-  if (typeof handlerOrDef === "function") {
-    handler = handlerOrDef;
-  } else {
-    handler = handlerOrDef.handler;
-    argsSchema = handlerOrDef.args;
-    isPublic = handlerOrDef.public === true;
-  }
-  const def = { key, handler, argsSchema, isPublic };
-  queryRegistry.set(key, def);
-  return def;
-}
-var mutationCounter = 0;
-function mutation(nameOrInvalidatesOrDef, handlerOrDef, name) {
-  let argsSchema;
-  let actualHandler;
-  let mutName;
-  let isPublic = false;
-  if (typeof nameOrInvalidatesOrDef === "string") {
-    mutName = nameOrInvalidatesOrDef;
-    const def2 = handlerOrDef;
-    actualHandler = def2.handler;
-    argsSchema = def2.args;
-    isPublic = def2.public === true;
-  } else if (Array.isArray(nameOrInvalidatesOrDef)) {
-    actualHandler = handlerOrDef;
-    mutName = name || `mutation_${++mutationCounter}`;
-  } else {
-    actualHandler = nameOrInvalidatesOrDef.handler;
-    argsSchema = nameOrInvalidatesOrDef.args;
-    isPublic = nameOrInvalidatesOrDef.public === true;
-    mutName = nameOrInvalidatesOrDef.name || (typeof name === "string" ? name : "") || `mutation_${++mutationCounter}`;
-  }
-  if (mutName.startsWith("mutation_")) {
-    console.warn(
-      `[gencow] mutation registered without explicit name \u2192 "${mutName}". Use mutation("myMutation", { handler }) for better debugging.`
-    );
-  }
-  const def = {
-    name: mutName,
-    handler: actualHandler,
-    argsSchema,
-    isPublic
-  };
-  mutationRegistry.push(def);
-  return def;
-}
-function httpAction(def) {
-  const actionDef = {
-    method: def.method,
-    path: def.path,
-    isPublic: def.public === true,
-    handler: def.handler
-  };
-  httpActionRegistry.push(actionDef);
-  return actionDef;
-}
-function getRegisteredHttpActions() {
-  return [...httpActionRegistry];
-}
 function subscribe(queryKey, ws) {
   connectedClients.add(ws);
   if (!subscribers.has(queryKey)) {
@@ -1839,19 +1798,66 @@ function handleWsMessage(ws, raw) {
   } catch {
   }
 }
-function getQueryHandler(key) {
-  return queryRegistry.get(key)?.handler;
-}
-function getQueryDef(key) {
-  return queryRegistry.get(key);
-}
-function getRegisteredQueries() {
-  return Array.from(queryRegistry.keys());
+
+// ../core/src/reactive-mutation.ts
+if (!globalThis.__gencow_mutationRegistry) globalThis.__gencow_mutationRegistry = [];
+var mutationRegistry = globalThis.__gencow_mutationRegistry;
+var mutationCounter = 0;
+function mutation(nameOrInvalidatesOrDef, handlerOrDef, name) {
+  let argsSchema;
+  let actualHandler;
+  let mutName;
+  let isPublic = false;
+  if (typeof nameOrInvalidatesOrDef === "string") {
+    mutName = nameOrInvalidatesOrDef;
+    const def2 = handlerOrDef;
+    actualHandler = def2.handler;
+    argsSchema = def2.args;
+    isPublic = def2.public === true;
+  } else if (Array.isArray(nameOrInvalidatesOrDef)) {
+    actualHandler = handlerOrDef;
+    mutName = name || `mutation_${++mutationCounter}`;
+  } else {
+    actualHandler = nameOrInvalidatesOrDef.handler;
+    argsSchema = nameOrInvalidatesOrDef.args;
+    isPublic = nameOrInvalidatesOrDef.public === true;
+    mutName = nameOrInvalidatesOrDef.name || (typeof name === "string" ? name : "") || `mutation_${++mutationCounter}`;
+  }
+  if (mutName.startsWith("mutation_")) {
+    console.warn(
+      `[gencow] mutation registered without explicit name \u2192 "${mutName}". Use mutation("myMutation", { handler }) for better debugging.`
+    );
+  }
+  const def = {
+    name: mutName,
+    handler: actualHandler,
+    argsSchema,
+    isPublic
+  };
+  mutationRegistry.push(def);
+  return def;
 }
 function getRegisteredMutations() {
   return [...mutationRegistry];
 }
 
+// ../core/src/http-action.ts
+if (!globalThis.__gencow_httpActionRegistry) globalThis.__gencow_httpActionRegistry = [];
+var httpActionRegistry = globalThis.__gencow_httpActionRegistry;
+function httpAction(def) {
+  const actionDef = {
+    method: def.method,
+    path: def.path,
+    isPublic: def.public === true,
+    handler: def.handler
+  };
+  httpActionRegistry.push(actionDef);
+  return actionDef;
+}
+function getRegisteredHttpActions() {
+  return [...httpActionRegistry];
+}
+
 // ../core/src/scheduler.ts
 var cron = __toESM(require_node_cron(), 1);
 var _cronInfo = globalThis.__gencow_cronInfo ??= [];

package/lib/deploy-command.mjs

@@ -2,15 +2,19 @@ import { BOLD, CYAN, DIM, GREEN, RED, RESET, YELLOW, error, info, log, success,
 import { readProjectAppTargets } from "./cloud-targets.mjs";
 
 export function renderDeployHelp() {
-  log(`\n${BOLD}${CYAN}gencow deploy${RESET} — Deploy backend to cloud\n`);
+  log(`\n${BOLD}${CYAN}gencow deploy${RESET} — Deploy backend or fullstack app to cloud\n`);
   log(`  ${BOLD}Usage:${RESET}  gencow deploy [options]\n`);
   log(`  ${BOLD}Options:${RESET}`);
+  log(`    ${DIM}--static [dir]${RESET}     Deploy backend first, then static files`);
+  log(`    ${DIM}--no-backend${RESET}       With --static, skip backend deployment`);
   log(`    ${DIM}--prod${RESET}             Deploy to production (Pro+ only)`);
   log(`    ${DIM}--rollback${RESET}          Rollback to previous deployment`);
   log(`    ${DIM}--force, -f${RESET}        Skip optional dependency scan`);
   log(`    ${DIM}--app, -a${RESET}          Target specific app\n`);
   log(`  ${BOLD}Examples:${RESET}`);
   log(`    gencow deploy`);
+  log(`    gencow deploy --static dist/`);
+  log(`    gencow deploy --static --no-backend dist/`);
   log(`    gencow deploy --prod`);
   log(`    gencow deploy --rollback\n`);
 }

package/lib/deploy-runtime.mjs

@@ -1,7 +1,13 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { basename, resolve } from "path";
 import { BOLD, CYAN, DIM, GREEN, RED, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
-import { createDeployPackageRuntime, writeProjectMetadata } from "./deploy-package-runtime.mjs";
+import { createDeployPackageRuntime } from "./deploy-package-runtime.mjs";
+import {
+  createScopedDeployPackageRuntime,
+  deployBackendPackage,
+  runStaticDeployFlow,
+} from "./deploy-static-fullstack-runtime.mjs";
+import { detectStaticDeployBackend } from "./static-deploy-command.mjs";
 
 export function parseDeployArgs(deployArgs) {
   const parsed = {
@@ -9,7 +15,9 @@ export function parseDeployArgs(deployArgs) {
     envTarget: "dev",
     forceDeploy: false,
     isRollback: false,
-    redirectStatic: false,
+    noBackend: false,
+    staticDeploy: false,
+    staticDirArg: null,
     unknownArg: null,
   };
 
@@ -19,12 +27,25 @@ export function parseDeployArgs(deployArgs) {
     else if (arg === "--force" || arg === "-f") parsed.forceDeploy = true;
     else if (arg === "--rollback") parsed.isRollback = true;
     else if (arg === "--app" || arg === "-a") parsed.appId = deployArgs[++index];
-    else if (arg === "--static") parsed.redirectStatic = true;
-    else if (arg === "--no-backend") {
-      // deprecated and ignored
+    else if (arg === "--static") {
+      parsed.staticDeploy = true;
+      const maybeDir = deployArgs[index + 1];
+      if (maybeDir && !maybeDir.startsWith("-")) {
+        parsed.staticDirArg = maybeDir;
+        index += 1;
+      }
+    } else if (arg.startsWith("--static=")) {
+      parsed.staticDeploy = true;
+      parsed.staticDirArg = arg.slice("--static=".length) || null;
+    } else if (arg === "--no-backend") {
+      parsed.noBackend = true;
     } else if (!arg.startsWith("-")) {
-      parsed.unknownArg = arg;
-      break;
+      if (parsed.staticDeploy && !parsed.staticDirArg) {
+        parsed.staticDirArg = arg;
+      } else {
+        parsed.unknownArg = arg;
+        break;
+      }
     }
   }
 
@@ -72,8 +93,8 @@ function showUnknownDeployArgument(arg, { errorImpl = error, infoImpl = info, lo
   infoImpl("  gencow deploy --force      Skip optional dependency scan");
   logImpl("");
   infoImpl("Static files:");
-  infoImpl("  gencow static [dir]        Deploy static files (dev)");
-  infoImpl("  gencow static --prod       Deploy static files (production)");
+  infoImpl("  gencow deploy --static [dir]              Deploy backend, then static files");
+  infoImpl("  gencow deploy --static --no-backend [dir] Deploy static files only");
 }
 
 async function confirmFirstProductionDeploy({ appId, createInterfaceImpl, infoImpl = info, logImpl = log }) {
@@ -235,8 +256,10 @@ async function runRollbackDeploy({
 }
 
 export function createDeployCommand({
+  createDeployPackageRuntimeImpl = createDeployPackageRuntime,
   createInterfaceImpl,
   cwdImpl = () => process.cwd(),
+  detectStaticDeployBackendImpl = detectStaticDeployBackend,
   errorImpl = error,
   existsSyncImpl = existsSync,
   exitImpl = (code) => process.exit(code),
@@ -249,11 +272,13 @@ export function createDeployCommand({
   processEnv = process.env,
   processRef = process,
   readFileSyncImpl = readFileSync,
+  readDeployProjectContextImpl = readDeployProjectContext,
   renderDeployHelpImpl,
   requireCredsImpl,
   resolvePathImpl = resolve,
   rpcMutationImpl,
   rpcQueryImpl,
+  runStaticDeployRuntimeImpl,
   setTimeoutImpl = setTimeout,
   successImpl = success,
   unlinkSyncImpl = unlinkSync,
@@ -263,8 +288,8 @@ export function createDeployCommand({
   drizzleKitCmdImpl,
   updateEnvLocalUrlImpl,
 } = {}) {
-  const deployPackageRuntime = createDeployPackageRuntime({
-    cwdImpl,
+  const packageRuntimeOptions = {
+    createDeployPackageRuntimeImpl,
     drizzleKitCmdImpl,
     errorImpl,
     existsSyncImpl,
@@ -285,7 +310,10 @@ export function createDeployCommand({
     warnImpl,
     writeFileSyncImpl,
     updateEnvLocalUrlImpl,
-  });
+  };
+  const createDeployPackageRuntimeForCwd = (scopedCwdImpl) =>
+    createScopedDeployPackageRuntime({ ...packageRuntimeOptions, scopedCwdImpl });
+  const deployPackageRuntime = createDeployPackageRuntimeForCwd(cwdImpl);
 
   return async function runDeployCommand(...deployArgs) {
     if (deployArgs.includes("--help") || deployArgs.includes("-h")) {
@@ -307,10 +335,6 @@ export function createDeployCommand({
     }
 
     const parsed = parseDeployArgs(deployArgs);
-    if (parsed.redirectStatic) {
-      warnImpl(`${YELLOW}--static is deprecated. Use: gencow static --prod${RESET}`);
-      return;
-    }
     if (parsed.unknownArg) {
       showUnknownDeployArgument(parsed.unknownArg, { errorImpl, infoImpl, logImpl });
       exitImpl(1);
@@ -318,8 +342,13 @@ export function createDeployCommand({
     }
 
     const cwd = cwdImpl();
-    const context = readDeployProjectContext({
-      cwd,
+    const staticBackend = parsed.staticDeploy
+      ? detectStaticDeployBackendImpl({ cwd, existsSyncImpl, resolvePathImpl })
+      : { detectedBackend: false, backendRoot: null };
+    const hasDetectedBackend = Boolean(staticBackend.detectedBackend && staticBackend.backendRoot);
+    const projectRoot = parsed.staticDeploy && hasDetectedBackend ? staticBackend.backendRoot : cwd;
+    const context = readDeployProjectContextImpl({
+      cwd: projectRoot,
       explicitAppId: parsed.appId,
       existsSyncImpl,
       readFileSyncImpl,
@@ -369,48 +398,51 @@ export function createDeployCommand({
       infoImpl(`Deploy target: ${CYAN}${appId}${RESET} (production)`);
     }
 
-    logImpl(`\n${BOLD}${CYAN}Gencow Deploy${RESET}\n`);
-    infoImpl(`App:    ${appId ? appId : "new (auto-generated ID)"}`);
-    infoImpl(`Env:    ${parsed.envTarget}${parsed.envTarget === "prod" ? ` ${YELLOW}(production)${RESET}` : ""}`);
-    infoImpl("Format: tar.gz");
-    logImpl("");
-
-    const packageResult = await deployPackageRuntime.packageDeployProject({ forceDeploy: parsed.forceDeploy });
-    if (!packageResult) return;
-
-    try {
-      const activeAppId = await deployPackageRuntime.createCloudAppIfNeeded({
-        creds,
+    if (parsed.staticDeploy) {
+      return runStaticDeployFlow({
         appId,
-        displayName,
-        gencowJsonPath,
-      });
-      const deployed = await deployPackageRuntime.deployBundleWithRetry({
+        backendRoot: staticBackend.backendRoot,
         creds,
-        appId: activeAppId,
-        bundleBuffer: packageResult.bundleBuffer,
         displayName,
         envTarget: parsed.envTarget,
+        forceDeploy: parsed.forceDeploy,
         gencowJsonPath,
+        hasDetectedBackend,
+        noBackend: parsed.noBackend,
+        staticDirArg: parsed.staticDirArg,
+        createDeployPackageRuntimeForCwd,
+        cwdImpl,
+        deployPackageRuntime,
+        errorImpl,
+        existsSyncImpl,
+        exitImpl,
+        infoImpl,
+        logImpl,
+        resolvePathImpl,
+        runStaticDeployRuntimeImpl,
+        unlinkSyncImpl,
+        writeFileSyncImpl,
       });
-      if (!deployed) return;
-
-      if (!existsSyncImpl(gencowJsonPath)) {
-        writeProjectMetadata({
-          appId: deployed.appId,
-          displayName,
-          platformUrl: creds.platformUrl,
-          gencowJsonPath,
-          writeFileSyncImpl,
-        });
-        infoImpl(`${DIM}gencow.json created${RESET}`);
-      }
-    } finally {
-      try {
-        unlinkSyncImpl(packageResult.tmpBundle);
-      } catch {
-        /* ignore */
-      }
     }
+
+    logImpl(`\n${BOLD}${CYAN}Gencow Deploy${RESET}\n`);
+    infoImpl(`App:    ${appId ? appId : "new (auto-generated ID)"}`);
+    infoImpl(`Env:    ${parsed.envTarget}${parsed.envTarget === "prod" ? ` ${YELLOW}(production)${RESET}` : ""}`);
+    infoImpl("Format: tar.gz");
+    logImpl("");
+
+    await deployBackendPackage({
+      activePackageRuntime: deployPackageRuntime,
+      appId,
+      creds,
+      displayName,
+      envTarget: parsed.envTarget,
+      forceDeploy: parsed.forceDeploy,
+      gencowJsonPath,
+      existsSyncImpl,
+      infoImpl,
+      unlinkSyncImpl,
+      writeFileSyncImpl,
+    });
   };
 }