gencow 0.1.258 → 0.1.260

package/lib/cli-command-runner.mjs

@@ -83,10 +83,16 @@ const SAFE_LOCAL_ERROR_CODES = new Map([
   [
     "CODEGEN_SOURCE_LOAD_FAILED",
     {
-      message: "Deploy stopped before upload: a backend source file throws while it is loaded.",
+      message: "Deploy stopped before upload: a backend source file could not be loaded.",
       stage: "codegen",
-      action:
-        "Retryable: yes, after the top-level code that throws during module load is fixed — run `npx gencow@latest codegen` to confirm it passes, then rerun your deploy command. The throw location is not available; check the backend files that run code at import time.",
+      action: (caught) => {
+        const cause =
+          "the top-level code that throws during module load, or an import path that does not resolve (check the path and that the imported package is installed)";
+        if (safeSourceLocation(caught)) {
+          return `Retryable: yes, after the source at the location above is fixed (${cause}) — run \`npx gencow@latest codegen\` to confirm it passes, then rerun your deploy command.`;
+        }
+        return `Retryable: yes, after ${cause} is fixed — run \`npx gencow@latest codegen\` to confirm it passes, then rerun your deploy command. The failing location is not available; check the backend files that run code at import time and the paths they import.`;
+      },
     },
   ],
   [

package/lib/cloud-targets.mjs

@@ -47,6 +47,14 @@ export function resolveProdAppTarget({ explicitAppId = null, prodApp = null, acc
   return { appId: prodApp };
 }
 
+// Single rule for the implicit prod environment: an explicit app id that is this project's
+// prod app selects the prod environment even without --prod. Every command that picks a
+// cloud app (cloud targets, deploy) must use this helper instead of repeating the condition.
+export function resolveImplicitProdEnvironment({ explicitApp = false, envTarget = "dev", appId = null, prodApp = null }) {
+  if (explicitApp && envTarget === "dev" && prodApp && appId === prodApp) return "prod";
+  return envTarget;
+}
+
 // Shared human message for a failed prod target; falls back to the call site's own text.
 export function describeProdTargetFailure(result, fallbackMessage) {
   if (result?.reason === "explicit_app_not_prod_app") {
@@ -81,10 +89,12 @@ export function resolveCloudAppTarget(restArgs, options = {}) {
   if (projectTargets.invalid) {
     return { error: "MIGRATION_PROJECT_CONFIG_INVALID" };
   }
-  // The project's own prod app id names the prod environment even without --prod.
-  if (explicitApp && envTarget === "dev" && projectTargets.prodApp && appId === projectTargets.prodApp) {
-    envTarget = "prod";
-  }
+  envTarget = resolveImplicitProdEnvironment({
+    explicitApp,
+    envTarget,
+    appId,
+    prodApp: projectTargets.prodApp,
+  });
   if (!appId) {
     appId = envTarget === "prod" ? projectTargets.prodApp : projectTargets.appId;
   }

package/lib/db-command.mjs

@@ -17,22 +17,36 @@ import { createDbCheckCommand, createDbPushCommand } from "./db-push-command.mjs
 import { logEnvFileOperationWithType } from "./backend-env-resolver.mjs";
 import { runDrizzleGenerateWithFallback } from "./drizzle-generate.mjs";
 import { BOLD, CYAN, DIM, GREEN, RED, RESET, error, info, log, success, warn } from "./output.mjs";
-import { describeProdTargetFailure, resolveProdAppTarget } from "./cloud-targets.mjs";
+import {
+  describeProdTargetFailure,
+  resolveImplicitProdEnvironment,
+  resolveProdAppTarget,
+} from "./cloud-targets.mjs";
 import { platformFetch, requireCreds } from "./platform-client.mjs";
 import { readProjectMetadata } from "./project-context.mjs";
 
 export function resolveDbCloudTarget(args, gencowJson = null) {
-  const isProd = args.includes("--prod");
   let explicitAppId = null;
+  let hasExplicitApp = false;
   let platformUrl = null;
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--app" || args[i] === "-a") {
       explicitAppId = args[i + 1] ?? null;
+      hasExplicitApp = true;
       i++;
     }
   }
 
+  // Same implicit prod rule as deploy and static: an --app naming the project's prodApp is prod even without --prod.
+  const isProd =
+    resolveImplicitProdEnvironment({
+      explicitApp: hasExplicitApp,
+      envTarget: args.includes("--prod") ? "prod" : "dev",
+      appId: explicitAppId,
+      prodApp: gencowJson?.prodApp || null,
+    }) === "prod";
+
   if (gencowJson) {
     platformUrl = gencowJson.platformUrl || null;
     if (isProd) {

package/lib/deploy-codegen-failure.mjs

@@ -33,6 +33,18 @@ function toProjectRelativePath(rawPath, cwd, processCwd) {
   return normalized;
 }
 
+// esbuild prints one diagnostic per line (`<file>:<line>:<col>: ERROR: <text>`) and the
+// Bun loader prints `Could not resolve`/`Cannot find module` for an import path that does
+// not exist. Those are load failures: the source is well-formed, its import is not.
+const DIAGNOSTIC_LINE_PATTERN = /ERROR: |Could not resolve "|Cannot find (?:module|package)\b/u;
+const UNRESOLVED_MODULE_PATTERN = /Could not resolve "|Cannot find (?:module|package)\b/u;
+
+// The first diagnostic decides the class, matching how the first location is reported.
+function isUnresolvedModuleFailure(message) {
+  const firstDiagnostic = message.split("\n").find((line) => DIAGNOSTIC_LINE_PATTERN.test(line)) ?? message;
+  return UNRESOLVED_MODULE_PATTERN.test(firstDiagnostic);
+}
+
 // Returns the first project-relative source location found in a raw message, or null.
 // Absolute paths, stacks and the raw text are never returned.
 function findProjectSourceLocation(message, { cwd, processCwd }) {
@@ -53,11 +65,14 @@ export function classifyDeployCodegenFailure(error, { cwd, backendRoot = "gencow
   const message = (error instanceof Error ? error.message : String(error ?? "")).slice(0, MAX_CLASSIFIED_MESSAGE_LENGTH);
   if (message.includes("Transpile error:")) {
     const location = findProjectSourceLocation(message, { cwd, processCwd });
+    const backendLocation = location && location.sourceFile.startsWith(`${backendRoot}/`) ? location : null;
+    if (isUnresolvedModuleFailure(message)) {
+      return { code: CODEGEN_FAILURE_CODES.SOURCE_LOAD_FAILED, ...(backendLocation ?? {}) };
+    }
     if (location) {
-      const inBackend = location.sourceFile.startsWith(`${backendRoot}/`);
       return {
         code: CODEGEN_FAILURE_CODES.SOURCE_SYNTAX_ERROR,
-        ...(inBackend ? location : {}),
+        ...(backendLocation ?? {}),
       };
     }
   }

package/lib/deploy-prepared-source.mjs

@@ -0,0 +1,37 @@
+import { unlinkSync } from "fs";
+
+// Local-only backend source preparation for a first `deploy --prod`. Every step here
+// reads the project on disk (capability check, migration generation, codegen, the
+// packaging audits and the bundle with its round-trip check). It runs once, before the
+// production app is created, so a rejection leaves no remote app behind.
+export async function prepareBackendSourceForProdCreate(
+  runtime,
+  { forceDeploy = false, requestId = null } = {},
+) {
+  if ((await runtime.preflightBackendCapability?.()) === false) return null;
+  const generatorVersion = await runtime.prepareDeployProjectSource?.({ existingBundleMode: false });
+  const packageResult = await runtime.packageDeployProject({
+    forceDeploy,
+    existingBundleMode: false,
+    requestId,
+    sourcePrepared: true,
+    preparedGeneratorVersion: generatorVersion,
+  });
+  if (!packageResult) return null;
+  return { runtime, generatorVersion, packageResult };
+}
+
+// Drops the temporary bundle file and codegen output of a prepared source that did not
+// reach the backend deploy (which otherwise releases them itself). Safe to call twice.
+export function releasePreparedBackendSource(prepared, { unlinkSyncImpl = unlinkSync } = {}) {
+  if (!prepared) return;
+  const tmpBundle = prepared.packageResult?.tmpBundle;
+  if (tmpBundle) {
+    try {
+      unlinkSyncImpl(tmpBundle);
+    } catch {
+      /* already removed */
+    }
+  }
+  prepared.runtime?.cleanupPreparedDeploySource?.();
+}

package/lib/deploy-prod-target.mjs

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+import { CONFIRMATION_MODE, resolveConfirmationMode } from "./confirm-gate.mjs";
+import { confirmFirstProductionDeploy } from "./deploy-first-prod-confirm.mjs";
+import { reconcileProductionAppTarget } from "./deploy-app-target.mjs";
+import { readJsonObjectResponse } from "./http-response-json.mjs";
+import { BOLD, DIM, GREEN, RED, RESET, error, info, log, success } from "./output.mjs";
+import { prodCreateFailureMessage } from "./prod-create-failure.mjs";
+
+export async function ensureProductionDeployTarget({
+  appId,
+  displayName,
+  createCloudAppIfNeeded,
+  createInterfaceImpl,
+  creds,
+  deployArgs,
+  gencowJsonPath,
+  platformFetchImpl,
+  processEnv = process.env,
+  readFileSyncImpl = readFileSync,
+  setTimeoutImpl = setTimeout,
+  successImpl = success,
+  errorImpl = error,
+  infoImpl = info,
+  logImpl = log,
+  writeFileSyncImpl = writeFileSync,
+  exitImpl = (code) => process.exit(code),
+  prodAppId = null,
+  region = null,
+  prepareLocalSource = null,
+}) {
+  const confirmMode = resolveConfirmationMode({
+    allowCiBypass: true,
+    args: deployArgs,
+    createInterfaceImpl,
+    processEnv,
+  });
+  // Without a recorded prod app, the first create always needs confirmation, so a
+  // non-interactive run fails before any platform lookup or create request.
+  if (!prodAppId && confirmMode === CONFIRMATION_MODE.NON_INTERACTIVE) {
+    await confirmFirstProductionDeploy({ appId, errorImpl, infoImpl, logImpl, mode: confirmMode, region });
+    exitImpl(1);
+    return null;
+  }
+  const reconciledTarget = await reconcileProductionAppTarget({
+    appId,
+    prodAppId,
+    creds,
+    displayName,
+    gencowJsonPath,
+    platformFetchImpl,
+    createCloudAppIfNeeded,
+    infoImpl,
+    errorImpl,
+    exitImpl,
+  });
+  if (!reconciledTarget) return null;
+  const productionParentAppId = reconciledTarget.appId;
+  const existingProdAppId = reconciledTarget.prodAppId;
+  if (existingProdAppId) return existingProdAppId;
+  if (!productionParentAppId) return null;
+
+  const proceed = await confirmFirstProductionDeploy({
+    appId: productionParentAppId,
+    createInterfaceImpl,
+    errorImpl,
+    infoImpl,
+    logImpl,
+    mode: confirmMode,
+    region,
+  });
+  if (!proceed) {
+    exitImpl(1);
+    return null;
+  }
+
+  // Local source validation must pass before any remote create: a rejected source
+  // (for example a codegen failure) must not leave an empty production app behind.
+  // The callback renders its own diagnosis and returns false when it aborts.
+  if (prepareLocalSource && !(await prepareLocalSource())) return null;
+
+  infoImpl("Creating prod app...");
+  const createProdRes = await platformFetchImpl(
+    creds,
+    `/platform/apps/${productionParentAppId}/create-prod`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(region ? { region } : {}),
+    },
+  );
+
+  if (!createProdRes.ok) {
+    const errData = await readJsonObjectResponse(createProdRes);
+    if (createProdRes.status === 403) {
+      logImpl("");
+      logImpl(`  ${RED}⛔ Production Deploy — Startup or Enterprise required${RESET}`);
+      logImpl("");
+      logImpl(`  ${DIM}gencow deploy --prod is for production deployment.${RESET}`);
+      logImpl("");
+      logImpl(`  ${BOLD}💡 Dev environment deploy:${RESET}`);
+      logImpl(`     ${GREEN}gencow deploy${RESET}          ${DIM}← Deploy backend to dev${RESET}`);
+      logImpl(`     ${GREEN}gencow dev${RESET}             ${DIM}← Real-time backend + live logs${RESET}`);
+      logImpl(`     ${GREEN}gencow static dist/${RESET}    ${DIM}← Static file (dist/) deploy${RESET}`);
+      logImpl("");
+      logImpl(`  ${BOLD}🚀 Unlock production deploy:${RESET}`);
+      logImpl(`     ${GREEN}gencow upgrade${RESET}       ${DIM}← Upgrade to Startup${RESET}`);
+      logImpl("");
+    } else {
+      errorImpl(prodCreateFailureMessage(errData, createProdRes));
+    }
+    exitImpl(1);
+    return null;
+  }
+
+  const createProdData = await readJsonObjectResponse(createProdRes);
+  if (!createProdData) {
+    errorImpl("Prod app creation failed: server returned an invalid JSON response");
+    exitImpl(1);
+    return null;
+  }
+  const nextProdAppId = createProdData.prodApp;
+  const gencowJson = existsSync(gencowJsonPath) ? JSON.parse(readFileSyncImpl(gencowJsonPath, "utf8")) : {};
+  gencowJson.prodApp = nextProdAppId;
+  writeFileSyncImpl(gencowJsonPath, JSON.stringify(gencowJson, null, 2));
+
+  if (createProdData.alreadyExists) {
+    infoImpl(`Prod app verified: ${nextProdAppId}`);
+    if (region && createProdData.region && createProdData.region !== region) {
+      infoImpl(
+        `Region unchanged: existing prod app is in ${createProdData.region}; --region only applies to first prod creation.`,
+      );
+    }
+  } else {
+    successImpl(`Prod app created: ${nextProdAppId}`);
+    infoImpl(`URL: ${createProdData.url}`);
+    if (createProdData.region) {
+      infoImpl(`Region: ${createProdData.region} (${createProdData.regionSource || "selected"})`);
+    }
+    await new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, 3000));
+  }
+
+  return nextProdAppId;
+}