convex 1.45.0 → 1.47.0

package/src/cli/lib/components/definition/bundle.ts

@@ -645,9 +645,11 @@ export async function bundleImplementations({
     functions: Bundle[];
     definitionPath: ComponentDefinitionPath;
   }[];
+  buildDebugInfos: BuildDebugInfo[];
 }> {
   let appImplementation;
   const componentImplementations = [];
+  const buildDebugInfos: BuildDebugInfo[] = [];
 
   // For --component-dir flag, skip bundling root implementations (no real code to bundle)
   const directoriesToBundle = rootComponentDirectory.syntheticComponentImport
@@ -660,13 +662,25 @@ export async function bundleImplementations({
       rootComponentDirectory.path,
       directory.path,
     );
+    // definitionPath is the canonical form
+    const definitionPath = toComponentDefinitionPath(
+      rootComponentDirectory,
+      directory,
+    );
     let schema;
-    if (ctx.fs.exists(path.resolve(resolvedPath, "schema.ts"))) {
-      schema =
-        (await bundleSchema(ctx, resolvedPath, extraConditions))[0] || null;
-    } else if (ctx.fs.exists(path.resolve(resolvedPath, "schema.js"))) {
-      schema =
-        (await bundleSchema(ctx, resolvedPath, extraConditions))[0] || null;
+    if (
+      ctx.fs.exists(path.resolve(resolvedPath, "schema.ts")) ||
+      ctx.fs.exists(path.resolve(resolvedPath, "schema.js"))
+    ) {
+      const schemaResult = await bundleSchema(
+        ctx,
+        resolvedPath,
+        extraConditions,
+      );
+      buildDebugInfos.push(
+        buildDebugInfo(directory, definitionPath, "schema", schemaResult),
+      );
+      schema = schemaResult.modules[0] || null;
     } else {
       schema = null;
     }
@@ -676,6 +690,7 @@ export async function bundleImplementations({
       modules: Bundle[];
       externalDependencies: Map<string, string>;
       bundledModuleNames: Set<string>;
+      metafile: Metafile | null;
     } = await bundle({
       ctx,
       dir: resolvedPath,
@@ -693,6 +708,9 @@ export async function bundleImplementations({
         printedMessage: "external dependencies not supported",
       });
     }
+    buildDebugInfos.push(
+      buildDebugInfo(directory, definitionPath, "convex", convexResult),
+    );
     const functions = convexResult.modules;
     if (isRoot) {
       if (verbose) {
@@ -702,6 +720,7 @@ export async function bundleImplementations({
         modules: Bundle[];
         externalDependencies: Map<string, string>;
         bundledModuleNames: Set<string>;
+        metafile: Metafile | null;
       } = await bundle({
         ctx,
         dir: resolvedPath,
@@ -713,6 +732,9 @@ export async function bundleImplementations({
         extraConditions,
         includeSourcesContent,
       });
+      buildDebugInfos.push(
+        buildDebugInfo(directory, definitionPath, "node", nodeResult),
+      );
 
       const externalNodeDependencies: NodeDependency[] = [];
       for (const [
@@ -724,10 +746,15 @@ export async function bundleImplementations({
           version: moduleVersion,
         });
       }
-      const authBundle = await bundleAuthConfig(ctx, resolvedPath);
+      const authResult = await bundleAuthConfig(ctx, resolvedPath);
+      buildDebugInfos.push(
+        buildDebugInfo(directory, definitionPath, "auth", authResult),
+      );
       appImplementation = {
         schema,
-        functions: functions.concat(nodeResult.modules).concat(authBundle),
+        functions: functions
+          .concat(nodeResult.modules)
+          .concat(authResult.modules),
         externalNodeDependencies,
       };
     } else {
@@ -757,11 +784,6 @@ export async function bundleImplementations({
           });
         }
       }
-      // definitionPath is the canonical form
-      const definitionPath = toComponentDefinitionPath(
-        rootComponentDirectory,
-        directory,
-      );
       componentImplementations.push({ definitionPath, schema, functions });
     }
   }
@@ -783,7 +805,39 @@ export async function bundleImplementations({
     }
   }
 
-  return { appImplementation, componentImplementations };
+  return { appImplementation, componentImplementations, buildDebugInfos };
+}
+
+/**
+ * Debug information for a build in a push.
+ */
+export type BuildDebugInfo = {
+  directory: ComponentDirectory;
+  definitionPath: ComponentDefinitionPath;
+  kind: "convex" | "node" | "schema" | "auth";
+  metafile: Metafile | null;
+  modules: Bundle[];
+  externalDependencies: Map<string, string>;
+};
+
+function buildDebugInfo(
+  directory: ComponentDirectory,
+  definitionPath: ComponentDefinitionPath,
+  kind: BuildDebugInfo["kind"],
+  result: {
+    modules: Bundle[];
+    metafile: Metafile | null;
+    externalDependencies?: Map<string, string>;
+  },
+): BuildDebugInfo {
+  return {
+    directory,
+    definitionPath,
+    kind,
+    metafile: result.metafile,
+    modules: result.modules,
+    externalDependencies: result.externalDependencies ?? new Map(),
+  };
 }
 
 async function registerEsbuildReads(

package/src/cli/lib/components.ts

@@ -52,6 +52,19 @@ import { DeploymentType } from "./api.js";
 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";
@@ -75,6 +88,12 @@ 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).
+  warnOnSlowSchemaValidation: boolean;
   message: string | null;
 };
 
@@ -120,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 {
@@ -229,6 +253,9 @@ async function startComponentsPushAndCodegen(
     pushAllModules?: boolean;
     debugNodeApis: boolean;
     largeIndexDeletionCheck: LargeIndexDeletionCheck;
+    largeIndexBackfillCheck: LargeIndexBackfillCheck;
+    stagedValidatorDeletionCheck: StagedValidatorDeletionCheck;
+    warnOnSlowSchemaValidation: boolean;
     codegenOnlyThisComponent?: string | undefined;
   },
 ): Promise<StartPushResponse | null> {
@@ -445,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({
@@ -452,12 +484,64 @@ async function startComponentsPushAndCodegen(
         span,
         request: startPushRequest,
         options,
+        schemaEvaluation,
         askForConfirmation:
           options.largeIndexDeletionCheck === "ask for confirmation",
       }),
     );
   }
 
+  const largeIndexBackfillCheck = options.largeIndexBackfillCheck;
+  if (largeIndexBackfillCheck !== "no verification") {
+    await parentSpan.enterAsync("checkForLargeIndexBackfill", (span) =>
+      checkForLargeIndexBackfill({
+        ctx,
+        span,
+        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,
+      }),
+    );
+  }
+
   changeSpinner("Uploading functions to Convex...");
   const startPushResponse = await parentSpan.enterAsync("startPush", (span) =>
     startPush(ctx, span, startPushRequest, options),

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

@@ -22,6 +22,10 @@ import {
   startPushResponse,
   StartPushResponse,
 } from "./deployApi/startPush.js";
+import {
+  EvaluateSchemaResponse,
+  evaluateSchemaResponse,
+} from "./deployApi/evaluateSchema.js";
 import {
   AppDefinitionConfig,
   ComponentDefinitionConfig,
@@ -103,6 +107,35 @@ export async function evaluatePush(
   return evaluatePushResponse.parse(response);
 }
 
+export async function evaluateSchema(
+  ctx: Context,
+  span: Span,
+  request: StartPushRequest,
+  options: {
+    url: string;
+    deploymentName: string | null;
+    deploymentType?: DeploymentType;
+  },
+  // When set, a failed evaluation throws the raw error instead of crashing
+  // the process, so best-effort callers (e.g. advisory checks) can recover.
+  bestEffort?: boolean,
+): Promise<EvaluateSchemaResponse> {
+  const response = await pushCode(
+    ctx,
+    span,
+    request,
+    options,
+    "/api/deploy2/evaluate_schema",
+    bestEffort,
+  );
+  return evaluateSchemaResponse.parse(response);
+}
+
+// Retries for best-effort requests, where a transient failure should be
+// ridden out if possible but the command proceeds without the result
+// otherwise.
+const BEST_EFFORT_RETRIES = 5;
+
 async function pushCode(
   ctx: Context,
   span: Span,
@@ -112,7 +145,11 @@ async function pushCode(
     deploymentName: string | null;
     deploymentType?: DeploymentType;
   },
-  endpoint: "/api/deploy2/start_push" | "/api/deploy2/evaluate_push",
+  endpoint:
+    | "/api/deploy2/start_push"
+    | "/api/deploy2/evaluate_push"
+    | "/api/deploy2/evaluate_schema",
+  bestEffort?: boolean,
 ): Promise<unknown> {
   // Log a summary of the push request instead of the full object
   const unchangedModuleCount =
@@ -136,6 +173,18 @@ async function pushCode(
     deploymentUrl: options.url,
     adminKey: request.adminKey,
     onError,
+    // Best-effort callers tolerate failure, so retry only plausibly
+    // transient conditions — network errors and 5xx responses (e.g. table
+    // summaries still bootstrapping) — and fail fast on everything else,
+    // like a 404 from a deployment whose backend doesn't yet expose the
+    // endpoint.
+    ...(bestEffort
+      ? {
+          maxRetries: BEST_EFFORT_RETRIES,
+          shouldRetry: (error: Error | null, response: Response | null) =>
+            error !== null || (response !== null && response.status >= 500),
+        }
+      : {}),
   });
   try {
     const response = await fetch(endpoint, {
@@ -149,6 +198,11 @@ async function pushCode(
     });
     return await response.json();
   } catch (error: unknown) {
+    if (bestEffort) {
+      // The caller handles this itself instead of crashing the process.
+      // eslint-disable-next-line no-restricted-syntax
+      throw error;
+    }
     return await handlePushConfigError(
       ctx,
       error,
@@ -403,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;
   },
 ) {
@@ -450,9 +506,17 @@ 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,
     message: options.message,
   };
   showSpinner(`Deploying to ${url}...${options.dryRun ? " [dry run]" : ""}`);

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

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { componentDefinitionPath, componentPath } from "./paths.js";
+import { developerIndexConfig } from "./finishPush.js";
+import { looseObject } from "./utils.js";
+
+// Hand-mirrors `TableValidationOutcome` in
+// `crates/common/src/schemas/mod.rs` (`#[serde(rename_all = "camelCase")]`),
+// like the rest of this deployApi directory: there's no codegen sharing
+// types between the Rust backend and this package.
+export const tableValidationOutcome = z.enum([
+  "notValidated",
+  "supersetOfEnforced",
+  "supersetOfStagedValidated",
+  "supersetOfShape",
+  "mustWalk",
+]);
+export type TableValidationOutcome = z.infer<typeof tableValidationOutcome>;
+
+export const indexChangePrediction = z.enum([
+  "added",
+  "identical",
+  "enabled",
+  "disabled",
+  "dropped",
+]);
+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>;
+
+export const indexPrediction = z.intersection(
+  developerIndexConfig,
+  looseObject({
+    change: indexChangePrediction,
+    needsBackfill: z.boolean(),
+    numDocs: z.number(),
+  }),
+);
+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
+>;
+
+export const evaluateSchemaResponse = looseObject({
+  componentSchemaEvaluations: z.record(
+    componentPath,
+    componentSchemaPrediction,
+  ),
+  newComponentDefinitions: z.array(componentDefinitionPath),
+});
+export type EvaluateSchemaResponse = z.infer<typeof evaluateSchemaResponse>;

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

@@ -45,7 +45,7 @@ export const cronDiff = looseObject({
 });
 export type CronDiff = z.infer<typeof cronDiff>;
 
-const developerIndexConfig = z.intersection(
+export const developerIndexConfig = z.intersection(
   z.discriminatedUnion("type", [
     looseObject({
       name: z.string(),

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

@@ -29,7 +29,7 @@ export type StartPushRequest = z.infer<typeof startPushRequest>;
 export const schemaChange = looseObject({
   allocatedComponentIds: z.any(),
   schemaIds: z.any(),
-  indexDiffs: z.record(componentDefinitionPath, indexDiff).optional(),
+  indexDiffs: z.record(componentPath, indexDiff).optional(),
 });
 export type SchemaChange = z.infer<typeof schemaChange>;
 

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,20 @@ 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,
       },
       devOptions,