convex 1.46.0 → 1.48.0-alpha.0

package/src/cli/lib/components.ts

@@ -53,6 +53,18 @@ import { deploymentDashboardUrlPage } from "./dashboard.js";
 import { formatIndex, LargeIndexDeletionCheck } from "./indexes.js";
 import { checkForLargeIndexDeletion } from "./checkForLargeIndexDeletion.js";
 import { checkForSlowSchemaValidation } from "./checkForSlowSchemaValidation.js";
+import {
+  checkForLargeIndexBackfill,
+  LargeIndexBackfillCheck,
+} from "./checkForLargeIndexBackfill.js";
+import {
+  pushStagesValidators,
+  sharedSchemaEvaluation,
+} from "./schemaEvaluation.js";
+import {
+  checkForStagedValidatorDeletion,
+  StagedValidatorDeletionCheck,
+} from "./checkForStagedValidatorDeletion.js";
 import { LogManager } from "./logs.js";
 import { createHash } from "crypto";
 import { Bundle, BundleHash } from "../../bundler/index.js";
@@ -76,6 +88,8 @@ export type PushOptions = {
   pushAllModules: boolean;
   logManager?: LogManager | undefined;
   largeIndexDeletionCheck: LargeIndexDeletionCheck;
+  largeIndexBackfillCheck: LargeIndexBackfillCheck;
+  stagedValidatorDeletionCheck: StagedValidatorDeletionCheck;
   // Whether a dry run should warn when the schema change would block the
   // deploy on a slow table walk. On for deploys; off for commands whose dry
   // runs never deploy (e.g. codegen).
@@ -125,6 +139,11 @@ export async function runCodegen(
         liveComponentSources: options.liveComponentSources,
         typecheckComponents: false,
         debugNodeApis: options.debugNodeApis,
+        // Code generation uses the source schema independently of deployment data.
+        largeIndexDeletionCheck: "no verification",
+        largeIndexBackfillCheck: "no verification",
+        stagedValidatorDeletionCheck: "no verification",
+        warnOnSlowSchemaValidation: false,
       },
     );
   } else {
@@ -234,6 +253,8 @@ async function startComponentsPushAndCodegen(
     pushAllModules?: boolean;
     debugNodeApis: boolean;
     largeIndexDeletionCheck: LargeIndexDeletionCheck;
+    largeIndexBackfillCheck: LargeIndexBackfillCheck;
+    stagedValidatorDeletionCheck: StagedValidatorDeletionCheck;
     warnOnSlowSchemaValidation: boolean;
     codegenOnlyThisComponent?: string | undefined;
   },
@@ -451,6 +472,11 @@ async function startComponentsPushAndCodegen(
   }
   logStartPushSizes(parentSpan, startPushRequest);
 
+  const schemaEvaluation = sharedSchemaEvaluation(
+    ctx,
+    startPushRequest,
+    options,
+  );
   if (options.largeIndexDeletionCheck !== "no verification") {
     await parentSpan.enterAsync("checkForLargeIndexDeletion", (span) =>
       checkForLargeIndexDeletion({
@@ -458,19 +484,60 @@ async function startComponentsPushAndCodegen(
         span,
         request: startPushRequest,
         options,
+        schemaEvaluation,
         askForConfirmation:
           options.largeIndexDeletionCheck === "ask for confirmation",
       }),
     );
   }
 
-  if (options.dryRun && options.warnOnSlowSchemaValidation) {
-    await parentSpan.enterAsync("checkForSlowSchemaValidation", (span) =>
-      checkForSlowSchemaValidation({
+  const largeIndexBackfillCheck = options.largeIndexBackfillCheck;
+  if (largeIndexBackfillCheck !== "no verification") {
+    await parentSpan.enterAsync("checkForLargeIndexBackfill", (span) =>
+      checkForLargeIndexBackfill({
         ctx,
         span,
-        request: startPushRequest,
+        schemaEvaluation,
         options,
+        // A dry run never blocks on a backfill, so it only reports.
+        mode: options.dryRun ? "warn" : largeIndexBackfillCheck,
+      }),
+    );
+  }
+
+  const stagedValidatorDeletionCheck = options.stagedValidatorDeletionCheck;
+  if (stagedValidatorDeletionCheck !== "no verification") {
+    await parentSpan.enterAsync(
+      "checkForStagedValidatorDeletion",
+      async (span) => {
+        const response = await schemaEvaluation(span);
+        await checkForStagedValidatorDeletion({
+          ctx,
+          response,
+          askForConfirmation:
+            stagedValidatorDeletionCheck === "ask for confirmation",
+          // A dry run previews the confirmation required by a real push.
+          dryRun: options.dryRun,
+        });
+      },
+    );
+  }
+
+  // A real push evaluates the schema only when the evaluation is already
+  // paid for by the unstaging check or the pushed schema stages a validator,
+  // so `dev` pushes of ordinary schemas skip the isolate evaluation and round
+  // trip that the status report would otherwise add on every save.
+  if (
+    options.warnOnSlowSchemaValidation &&
+    (options.dryRun ||
+      stagedValidatorDeletionCheck !== "no verification" ||
+      pushStagesValidators(startPushRequest))
+  ) {
+    await parentSpan.enterAsync("checkForSlowSchemaValidation", (span) =>
+      checkForSlowSchemaValidation({
+        span,
+        schemaEvaluation,
+        dryRun: options.dryRun,
       }),
     );
   }

package/src/cli/lib/config.ts

@@ -42,6 +42,7 @@ import {
 } from "./localDeployment/errors.js";
 import { debugIsolateBundlesSerially } from "../../bundler/debugBundle.js";
 import { DeploymentType } from "./api.js";
+import { isAnonymousDeployment } from "./deployment.js";
 export { productionProvisionHost, provisionHost } from "./utils/utils.js";
 
 /** Type representing WorkOS AuthKit integration configuration. */
@@ -672,7 +673,7 @@ export async function configFromProjectConfig(
   }
   const modules = convexResult.modules;
   modules.push(...nodeResult.modules);
-  modules.push(...(await bundleAuthConfig(ctx, baseDir)));
+  modules.push(...(await bundleAuthConfig(ctx, baseDir)).modules);
 
   const nodeDependencies: NodeDependency[] = [];
   for (const [moduleName, moduleVersion] of nodeResult.externalDependencies) {
@@ -911,6 +912,49 @@ export function diffConfig(
   return { diffString: diff };
 }
 
+export function setEnvVarsInstructions(
+  names: string[],
+  deploymentName: string | null,
+  deploymentType: DeploymentType | undefined,
+  deploymentUrl: string | undefined,
+): string {
+  // Name cloud deployments explicitly: without a flag `env set` targets the
+  // project's default dev deployment, which may not be where this push went
+  // (e.g. `npx convex dev --deployment <other dev deployment>`). Local and
+  // anonymous deployments are always the default target.
+  let deploymentFlag = "";
+  if (
+    deploymentName !== null &&
+    deploymentType !== "local" &&
+    deploymentType !== "anonymous"
+  ) {
+    deploymentFlag = ` --deployment ${deploymentName}`;
+  } else if (deploymentType === "prod") {
+    deploymentFlag = " --prod";
+  } else if (deploymentName === null && deploymentUrl !== undefined) {
+    // Pushes via `--url`/`--admin-key` or self-hosted env vars have no
+    // deployment name. The admin key stays a placeholder to keep it out of
+    // terminal output.
+    deploymentFlag = ` --url ${deploymentUrl} --admin-key <admin key>`;
+  }
+  const commands = (names.length > 0 ? names : ["<NAME>"]).map(
+    (name) =>
+      `    ${chalkStderr.bold(`npx convex env set${deploymentFlag} ${name} <value>`)}`,
+  );
+  let instructions = `Set ${names.length > 1 ? "them" : "it"} with:\n\n${commands.join("\n")}\n`;
+  // Anonymous deployments are only reachable from the local dashboard, which
+  // `deploymentDashboardUrlPage` can't address.
+  if (deploymentName !== null && !isAnonymousDeployment(deploymentName)) {
+    const variableQuery = names.length === 1 ? `?var=${names[0]}` : "";
+    const dashboardUrl = deploymentDashboardUrlPage(
+      deploymentName,
+      `/settings/environment-variables${variableQuery}`,
+    );
+    instructions += `\nor in the dashboard:\n\n    ${chalkStderr.bold(dashboardUrl)}\n`;
+  }
+  return instructions;
+}
+
 /** Handle an error from
  * legacy push path:
  * - /api/push_config
@@ -934,7 +978,7 @@ export async function handlePushConfigError(
         deploymentNotice: string;
       }
     | undefined,
-  _deploymentType: DeploymentType | undefined,
+  deploymentType: DeploymentType | undefined,
 ): Promise<never> {
   const data: ErrorData | undefined =
     error instanceof ThrowingFetchError ? error.serverErrorData : undefined;
@@ -965,26 +1009,49 @@ export async function handlePushConfigError(
       `Environment variable ${chalkStderr.bold(
         variableName,
       )} is used in auth config file but ` + `its value was not set.`;
-    let setEnvVarInstructions =
-      "Go set it in the dashboard or using `npx convex env set`";
-
-    // If `npx convex dev` is running using --url there might not be a configured deployment
-    if (deploymentName !== null) {
-      const variableQuery =
-        variableName !== undefined ? `?var=${variableName}` : "";
-      const dashboardUrl = deploymentDashboardUrlPage(
-        deploymentName,
-        `/settings/environment-variables${variableQuery}`,
-      );
-      setEnvVarInstructions = `Go to:\n\n    ${chalkStderr.bold(
-        dashboardUrl,
-      )}\n\n  to set it up. `;
-    }
     await ctx.crash({
       exitCode: 1,
       errorType: "invalid filesystem or env vars",
       errForSentry: error,
-      printedMessage: envVarMessage + "\n" + setEnvVarInstructions,
+      printedMessage:
+        envVarMessage +
+        "\n" +
+        setEnvVarsInstructions(
+          variableName !== undefined ? [variableName] : [],
+          deploymentName,
+          deploymentType,
+          deployment?.deploymentUrl,
+        ),
+    });
+  }
+
+  if (data?.code === "MissingEnvironmentVariables") {
+    const errorMessage = data.message || "(no error message given)";
+    const [, namesList] = errorMessage.match(/are not set: ([^.]+)\./) ?? [];
+    const names = namesList?.split(", ") ?? [];
+    const envVarMessage =
+      names.length === 0
+        ? errorMessage
+        : names.length === 1
+          ? `Environment variable ${chalkStderr.bold(names[0])} is ` +
+            `declared as required in convex.config.ts but its value was not set.`
+          : `Environment variables ${names
+              .map((name) => chalkStderr.bold(name))
+              .join(", ")} are declared as required in convex.config.ts ` +
+            `but their values were not set.`;
+    await ctx.crash({
+      exitCode: 1,
+      errorType: "invalid filesystem or env vars",
+      errForSentry: error,
+      printedMessage:
+        envVarMessage +
+        "\n" +
+        setEnvVarsInstructions(
+          names,
+          deploymentName,
+          deploymentType,
+          deployment?.deploymentUrl,
+        ),
     });
   }
 

package/src/cli/lib/deploy2.ts

@@ -457,7 +457,9 @@ export async function deployToDeployment(
     writePushRequest?: string | undefined;
     liveComponentSources?: boolean | undefined;
     skipWorkosCheck?: boolean | undefined;
+    skipLargeIndexesCheck: boolean;
     allowDeletingLargeIndexes: boolean;
+    allowUnstagingSchema: boolean;
     message: string | null;
   },
 ) {
@@ -504,7 +506,14 @@ export async function deployToDeployment(
     writePushRequest: options.writePushRequest,
     liveComponentSources: !!options.liveComponentSources,
     pushAllModules: !!options.pushAllModules,
-    largeIndexDeletionCheck: options.allowDeletingLargeIndexes
+    largeIndexDeletionCheck:
+      options.skipLargeIndexesCheck || options.allowDeletingLargeIndexes
+        ? "has confirmation"
+        : "ask for confirmation",
+    largeIndexBackfillCheck: options.skipLargeIndexesCheck
+      ? "has confirmation"
+      : "ask for confirmation",
+    stagedValidatorDeletionCheck: options.allowUnstagingSchema
       ? "has confirmation"
       : "ask for confirmation",
     warnOnSlowSchemaValidation: true,

package/src/cli/lib/deployApi/evaluateSchema.ts

@@ -10,6 +10,7 @@ import { looseObject } from "./utils.js";
 export const tableValidationOutcome = z.enum([
   "notValidated",
   "supersetOfEnforced",
+  "supersetOfStagedValidated",
   "supersetOfShape",
   "mustWalk",
 ]);
@@ -24,11 +25,26 @@ export const indexChangePrediction = z.enum([
 ]);
 export type IndexChangePrediction = z.infer<typeof indexChangePrediction>;
 
+// Mirrors `StagedValidatorState` in
+// `crates/application/src/deploy_config.rs`.
+export const stagedValidatorState = z.union([
+  looseObject({
+    state: z.literal("pending"),
+    numDocsValidated: z.number(),
+    totalDocs: z.number().nullable().optional(),
+  }),
+  looseObject({ state: z.literal("valid") }),
+  looseObject({ state: z.literal("failed"), error: z.string() }),
+]);
+export type StagedValidatorState = z.infer<typeof stagedValidatorState>;
+
 export const tablePrediction = looseObject({
   name: z.string(),
   outcome: tableValidationOutcome,
   numDocs: z.number(),
   sizeBytes: z.number(),
+  staged: stagedValidatorState.optional(),
+  canSkipAfterStagedValidation: z.boolean().optional(),
 });
 export type TablePrediction = z.infer<typeof tablePrediction>;
 
@@ -42,11 +58,30 @@ export const indexPrediction = z.intersection(
 );
 export type IndexPrediction = z.infer<typeof indexPrediction>;
 
+// Mirrors `SerializedDiscardedStagedValidator` in
+// `crates/local_backend/src/deploy_config2.rs`. The backend never discards a
+// failed validator, since a redeploy retries it anyway.
+export const discardedStagedValidator = looseObject({
+  tableName: z.string(),
+  state: z.union([
+    looseObject({
+      state: z.literal("pending"),
+      numDocsValidated: z.number(),
+      totalDocs: z.number().nullable().optional(),
+    }),
+    looseObject({ state: z.literal("valid") }),
+  ]),
+  replaced: z.boolean(),
+});
+export type DiscardedStagedValidator = z.infer<typeof discardedStagedValidator>;
+
 export const componentSchemaPrediction = looseObject({
   definitionPath: z.string(),
   schemaValidation: z.boolean(),
   tables: z.array(tablePrediction),
   indexes: z.array(indexPrediction),
+  // Optional: responses from backends predating the field.
+  discardedStagedValidators: z.array(discardedStagedValidator).optional(),
 });
 export type ComponentSchemaPrediction = z.infer<
   typeof componentSchemaPrediction

package/src/cli/lib/deployKeyWarning.ts

@@ -0,0 +1,43 @@
+import { Context } from "../../bundler/context.js";
+import { logWarning } from "../../bundler/log.js";
+import {
+  deploymentNameFromAdminKey,
+  deploymentTypeFromAdminKey,
+  isDeploymentKey,
+  isPreviewDeployKey,
+  isProjectKey,
+} from "./deployment.js";
+import { getDeployKeySource } from "./envvars.js";
+import { IGNORED_DEPLOY_KEY, readDeployKeyFromEnv } from "./utils/utils.js";
+
+const warnedContexts = new WeakSet<Context>();
+
+export function warnIfDeployKeyOverridesLogin(
+  ctx: Context,
+  hasAccount: boolean,
+) {
+  if (
+    !hasAccount ||
+    warnedContexts.has(ctx) ||
+    process.env.CONVEX_OVERRIDE_ACCESS_TOKEN
+  )
+    return;
+  const key = readDeployKeyFromEnv((name) => process.env[name]);
+  if (
+    key === undefined ||
+    key === IGNORED_DEPLOY_KEY ||
+    isPreviewDeployKey(key)
+  )
+    return;
+  const { envVarName, source } = getDeployKeySource(key);
+  const type = deploymentTypeFromAdminKey(key);
+  const target = isDeploymentKey(key)
+    ? `${type === "prod" ? "production" : type} deployment "${deploymentNameFromAdminKey(key)}"`
+    : isProjectKey(key)
+      ? "the project selected by the key"
+      : "the deployment selected by the key";
+  logWarning(
+    `WARNING: ${envVarName} in ${source} overrides your Convex account for deployment commands. They target ${target}. Remove ${envVarName} to use the selected account.`,
+  );
+  warnedContexts.add(ctx);
+}

package/src/cli/lib/deployment.ts

@@ -102,7 +102,7 @@ export async function eraseDeploymentEnvVar(ctx: Context): Promise<boolean> {
   return true;
 }
 
-async function gitIgnoreEnvVarFile(ctx: Context): Promise<boolean> {
+export async function gitIgnoreEnvVarFile(ctx: Context): Promise<boolean> {
   const gitIgnorePath = ".gitignore";
   const gitIgnoreContents = ctx.fs.exists(gitIgnorePath)
     ? ctx.fs.readUtf8File(gitIgnorePath)
@@ -186,7 +186,7 @@ export async function deploymentNameFromAdminKeyOrCrash(
   return deploymentName;
 }
 
-function deploymentNameFromAdminKey(adminKey: string) {
+export function deploymentNameFromAdminKey(adminKey: string) {
   const parts = adminKey.split("|");
   if (parts.length === 1) {
     return null;

package/src/cli/lib/deploymentSelection.ts

@@ -31,18 +31,26 @@ import {
   targetProjectForLocalSelector,
 } from "./localDeployment/projectMismatch.js";
 import { chalkStderr } from "chalk";
-import { getBuildEnvironment } from "./envvars.js";
+import {
+  getBuildEnvironment,
+  loadProjectEnvironmentVariables,
+} from "./envvars.js";
 import { readGlobalConfig } from "./utils/globalConfig.js";
+import {
+  getProfileSelection,
+  ProfileSelection,
+  readProfileAuth,
+} from "./profiles.js";
 import {
   CONVEX_DEPLOYMENT_ENV_VAR_NAME,
   CONVEX_DEPLOYMENT_TOKEN_ENV_VAR_NAME,
   CONVEX_DEPLOY_KEY_ENV_VAR_NAME,
   CONVEX_SELF_HOSTED_ADMIN_KEY_VAR_NAME,
   CONVEX_SELF_HOSTED_URL_VAR_NAME,
-  ENV_VAR_FILE_PATH,
   bigBrainAPI,
   processDeployKeyValue,
   readDeployKeyFromEnv,
+  readDeployKeyEnvVar,
   typedPlatformClient,
 } from "./utils/utils.js";
 import * as dotenv from "dotenv";
@@ -83,10 +91,11 @@ export async function initializeBigBrainAuth(
   if (initialArgs.url !== undefined && initialArgs.adminKey !== undefined) {
     // Do not check any env vars if `url` and `adminKey` are specified via CLI
     ctx._updateBigBrainAuth(
-      getBigBrainAuth(ctx, {
+      await getBigBrainAuth(ctx, {
         previewDeployKey: null,
         projectKey: null,
         deploymentKey: null,
+        skipProfile: true,
       }),
     );
     return;
@@ -106,30 +115,31 @@ export async function initializeBigBrainAuth(
     const rawDeployKey = readDeployKeyFromEnv((name) => config[name]);
     const deployKey = await processDeployKeyValue(ctx, rawDeployKey);
     if (deployKey !== undefined) {
-      const bigBrainAuth = getBigBrainAuth(ctx, {
+      const bigBrainAuth = await getBigBrainAuth(ctx, {
         previewDeployKey: isPreviewDeployKey(deployKey) ? deployKey : null,
         projectKey: isProjectKey(deployKey) ? deployKey : null,
         deploymentKey: isDeploymentKey(deployKey) ? deployKey : null,
+        envFile: initialArgs.envFile,
       });
       ctx._updateBigBrainAuth(bigBrainAuth);
       return;
     }
     // No deploy key was found in the env file, so fall back on using the global config
     ctx._updateBigBrainAuth(
-      getBigBrainAuth(ctx, {
+      await getBigBrainAuth(ctx, {
         previewDeployKey: null,
         projectKey: null,
         deploymentKey: null,
+        envFile: initialArgs.envFile,
       }),
     );
     return;
   }
-  dotenv.config({ path: ENV_VAR_FILE_PATH });
-  dotenv.config();
+  loadProjectEnvironmentVariables();
   const rawDeployKey = readDeployKeyFromEnv((name) => process.env[name]);
   const deployKey = await processDeployKeyValue(ctx, rawDeployKey);
   if (deployKey !== undefined) {
-    const bigBrainAuth = getBigBrainAuth(ctx, {
+    const bigBrainAuth = await getBigBrainAuth(ctx, {
       previewDeployKey: isPreviewDeployKey(deployKey) ? deployKey : null,
       projectKey: isProjectKey(deployKey) ? deployKey : null,
       deploymentKey: isDeploymentKey(deployKey) ? deployKey : null,
@@ -138,7 +148,7 @@ export async function initializeBigBrainAuth(
     return;
   }
   ctx._updateBigBrainAuth(
-    getBigBrainAuth(ctx, {
+    await getBigBrainAuth(ctx, {
       previewDeployKey: null,
       projectKey: null,
       deploymentKey: null,
@@ -150,6 +160,7 @@ export async function initializeBigBrainAuth(
 export async function updateBigBrainAuthAfterLogin(
   ctx: Context,
   accessToken: string,
+  profile?: ProfileSelection,
 ) {
   const existingAuth = ctx.bigBrainAuth();
   if (existingAuth !== null && existingAuth.kind === "projectKey") {
@@ -162,6 +173,7 @@ export async function updateBigBrainAuthAfterLogin(
     accessToken: accessToken,
     kind: "accessToken",
     header: `Bearer ${accessToken}`,
+    ...(profile ? { profile } : {}),
   });
 }
 
@@ -169,19 +181,22 @@ export async function clearBigBrainAuth(ctx: Context) {
   ctx._updateBigBrainAuth(null);
 }
 
-function getBigBrainAuth(
+async function getBigBrainAuth(
   ctx: Context,
   opts: {
     previewDeployKey: string | null;
     projectKey: string | null;
     deploymentKey: string | null;
+    envFile?: string;
+    skipProfile?: boolean;
   },
-): BigBrainAuth | null {
+): Promise<BigBrainAuth | null> {
   if (process.env.CONVEX_OVERRIDE_ACCESS_TOKEN) {
     return {
       accessToken: process.env.CONVEX_OVERRIDE_ACCESS_TOKEN,
       kind: "accessToken",
       header: `Bearer ${process.env.CONVEX_OVERRIDE_ACCESS_TOKEN}`,
+      profile: null,
     };
   }
   if (opts.projectKey !== null) {
@@ -200,12 +215,19 @@ function getBigBrainAuth(
       deploymentKey: opts.deploymentKey,
     };
   }
+  const profile = opts.skipProfile
+    ? null
+    : await getProfileSelection(ctx, { envFile: opts.envFile });
+  if (profile !== null) {
+    return await readProfileAuth(ctx, profile);
+  }
   const globalConfig = readGlobalConfig(ctx);
   if (globalConfig) {
     return {
       kind: "accessToken",
       header: `Bearer ${globalConfig.accessToken}`,
       accessToken: globalConfig.accessToken,
+      profile: null,
     };
   }
   if (opts.previewDeployKey !== null) {
@@ -272,9 +294,9 @@ export async function ensureAuthCanCreateDeployment(
       )} and try again.`,
     });
   }
-  const envVar = process.env[CONVEX_DEPLOY_KEY_ENV_VAR_NAME]
-    ? CONVEX_DEPLOY_KEY_ENV_VAR_NAME
-    : CONVEX_DEPLOYMENT_TOKEN_ENV_VAR_NAME;
+  const envVar =
+    readDeployKeyEnvVar((name) => process.env[name])?.name ??
+    CONVEX_DEPLOY_KEY_ENV_VAR_NAME;
   return await ctx.crash({
     exitCode: 1,
     errorType: "fatal",
@@ -569,10 +591,7 @@ async function resolveBaseDeploymentSelection(
     }
     return result.metadata;
   }
-  // start with .env.local (but doesn't override existing)
-  dotenv.config({ path: ENV_VAR_FILE_PATH });
-  // for variables not already set, use .env values
-  dotenv.config();
+  loadProjectEnvironmentVariables();
   const result = await getDeploymentSelectionFromEnv(
     ctx,
     selectionWithinProject,

package/src/cli/lib/dev.ts

@@ -60,6 +60,7 @@ export async function devAgainstDeployment(
     debugNodeApis: boolean;
     liveComponentSources: boolean;
     pushAllModules: boolean;
+    allowUnstagingSchema: boolean;
   },
 ) {
   const logManager = new LogManager(devOptions.tailLogs);
@@ -148,6 +149,19 @@ export async function devAgainstDeployment(
         pushAllModules: devOptions.pushAllModules,
         logManager, // Pass logManager to control logs during deploy
         largeIndexDeletionCheck: "no verification", // `convex dev` can’t push to prod
+        // `convex dev --prod` pushes straight to production, where an
+        // unstaged index on a large table blocks the push for the whole
+        // backfill; dev deployments are small enough to let it through.
+        largeIndexBackfillCheck:
+          credentials.deploymentType === "prod"
+            ? "ask for confirmation"
+            : "no verification",
+        stagedValidatorDeletionCheck:
+          credentials.deploymentType === "prod"
+            ? devOptions.allowUnstagingSchema
+              ? "has confirmation"
+              : "ask for confirmation"
+            : "no verification",
         warnOnSlowSchemaValidation: true,
         message: null,
       },

package/src/cli/lib/envvars.ts

@@ -6,7 +6,49 @@ import * as dotenv from "dotenv";
 
 import { Context } from "../../bundler/context.js";
 import { logWarning } from "../../bundler/log.js";
-import { loadPackageJson } from "./utils/utils.js";
+import {
+  CONVEX_DEPLOY_KEY_ENV_VAR_NAME,
+  readDeployKeyEnvVar,
+  ENV_VAR_FILE_PATH,
+  loadPackageJson,
+} from "./utils/utils.js";
+
+export const CONVEX_ACCOUNT_ENV_VAR = "CONVEX_ACCOUNT";
+
+const loadedEnvironment = new Map<string, { value: string; source: string }>();
+
+export function loadProjectEnvironmentVariables() {
+  // Only remove values supplied by our previous load; later shell overrides win.
+  for (const [name, { value }] of loadedEnvironment) {
+    if (process.env[name] === value) delete process.env[name];
+  }
+  loadedEnvironment.clear();
+  const environment: Record<string, string> = {};
+  for (const [name, value] of Object.entries(process.env)) {
+    if (value !== undefined) environment[name] = value;
+  }
+  for (const file of [ENV_VAR_FILE_PATH, ".env"]) {
+    dotenv.config({ path: file, processEnv: environment });
+    for (const [name, value] of Object.entries(environment)) {
+      // Account selection reads the current project's files directly.
+      if (name !== CONVEX_ACCOUNT_ENV_VAR && process.env[name] === undefined) {
+        process.env[name] = value;
+        loadedEnvironment.set(name, { value, source: file });
+      }
+    }
+  }
+}
+
+export function getDeployKeySource(key: string) {
+  const envVarName =
+    readDeployKeyEnvVar((name) => process.env[name])?.name ??
+    CONVEX_DEPLOY_KEY_ENV_VAR_NAME;
+  const loaded = loadedEnvironment.get(envVarName);
+  return {
+    envVarName,
+    source: loaded?.value === key ? loaded.source : "shell environment",
+  };
+}
 
 const _FRAMEWORKS = [
   "create-react-app",