@prisma-next/cli 0.1.0-dev.3 → 0.1.0-dev.30

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/commands/contract-emit.ts
 import { mkdirSync, writeFileSync } from "fs";
@@ -52,6 +52,45 @@ async function loadConfig(configPath) {
   }
 }
 
+// src/utils/action.ts
+import { notOk, ok } from "@prisma-next/utils/result";
+
+// src/utils/cli-errors.ts
+import {
+  CliStructuredError,
+  errorConfigFileNotFound as errorConfigFileNotFound2,
+  errorConfigValidation,
+  errorContractConfigMissing,
+  errorContractMissingExtensionPacks,
+  errorContractValidationFailed,
+  errorDatabaseUrlRequired,
+  errorDriverRequired,
+  errorFamilyReadMarkerSqlRequired,
+  errorFileNotFound,
+  errorHashMismatch,
+  errorJsonFormatNotSupported,
+  errorMarkerMissing,
+  errorMigrationPlanningFailed,
+  errorQueryRunnerFactoryRequired,
+  errorRuntime,
+  errorTargetMigrationNotSupported,
+  errorTargetMismatch,
+  errorUnexpected as errorUnexpected2
+} from "@prisma-next/core-control-plane/errors";
+
+// src/utils/action.ts
+async function performAction(fn) {
+  try {
+    const value = await fn();
+    return ok(value);
+  } catch (error) {
+    if (error instanceof CliStructuredError) {
+      return notOk(error);
+    }
+    throw error;
+  }
+}
+
 // src/utils/command-helpers.ts
 function setCommandDescriptions(command, shortDescription, longDescription) {
   command.description(shortDescription);
@@ -165,6 +204,36 @@ function formatErrorOutput(error, flags) {
     const whereLine = error.where.line ? `${error.where.path}:${error.where.line}` : error.where.path;
     lines.push(`${prefix}${formatDimText(`  Where: ${whereLine}`)}`);
   }
+  if (error.meta?.["conflicts"]) {
+    const conflicts = error.meta["conflicts"];
+    if (conflicts.length > 0) {
+      const maxToShow = isVerbose(flags, 1) ? conflicts.length : Math.min(3, conflicts.length);
+      const header = isVerbose(flags, 1) ? "  Conflicts:" : `  Conflicts (showing ${maxToShow} of ${conflicts.length}):`;
+      lines.push(`${prefix}${formatDimText(header)}`);
+      for (const conflict of conflicts.slice(0, maxToShow)) {
+        lines.push(`${prefix}${formatDimText(`    - [${conflict.kind}] ${conflict.summary}`)}`);
+      }
+      if (!isVerbose(flags, 1) && conflicts.length > maxToShow) {
+        lines.push(`${prefix}${formatDimText("  Re-run with -v/--verbose to see all conflicts")}`);
+      }
+    }
+  }
+  if (error.meta?.["issues"]) {
+    const issues = error.meta["issues"];
+    if (issues.length > 0) {
+      const maxToShow = isVerbose(flags, 1) ? issues.length : Math.min(3, issues.length);
+      const header = isVerbose(flags, 1) ? "  Issues:" : `  Issues (showing ${maxToShow} of ${issues.length}):`;
+      lines.push(`${prefix}${formatDimText(header)}`);
+      for (const issue of issues.slice(0, maxToShow)) {
+        const kind = issue.kind ?? "issue";
+        const message = issue.message ?? "";
+        lines.push(`${prefix}${formatDimText(`    - [${kind}] ${message}`)}`);
+      }
+      if (!isVerbose(flags, 1) && issues.length > maxToShow) {
+        lines.push(`${prefix}${formatDimText("  Re-run with -v/--verbose to see all issues")}`);
+      }
+    }
+  }
   if (error.docsUrl && isVerbose(flags, 1)) {
     lines.push(formatDimText(error.docsUrl));
   }
@@ -598,6 +667,69 @@ function formatSignOutput(result, flags) {
 function formatSignJson(result) {
   return JSON.stringify(result, null, 2);
 }
+function formatDbInitPlanOutput(result, flags) {
+  if (flags.quiet) {
+    return "";
+  }
+  const lines = [];
+  const prefix = createPrefix(flags);
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  const formatDimText = (text) => formatDim(useColor, text);
+  const operationCount = result.plan?.operations.length ?? 0;
+  lines.push(`${prefix}${formatGreen("\u2714")} Planned ${operationCount} operation(s)`);
+  if (result.plan?.operations && result.plan.operations.length > 0) {
+    lines.push(`${prefix}${formatDimText("\u2502")}`);
+    for (let i = 0; i < result.plan.operations.length; i++) {
+      const op = result.plan.operations[i];
+      if (!op) continue;
+      const isLast = i === result.plan.operations.length - 1;
+      const treeChar = isLast ? "\u2514" : "\u251C";
+      const opClass = formatDimText(`[${op.operationClass}]`);
+      lines.push(`${prefix}${formatDimText(treeChar)}\u2500 ${op.label} ${opClass}`);
+    }
+  }
+  if (result.plan?.destination) {
+    lines.push(`${prefix}`);
+    lines.push(
+      `${prefix}${formatDimText(`Destination hash: ${result.plan.destination.coreHash}`)}`
+    );
+  }
+  if (isVerbose(flags, 1)) {
+    lines.push(`${prefix}${formatDimText(`Total time: ${result.timings.total}ms`)}`);
+  }
+  lines.push(`${prefix}`);
+  lines.push(`${prefix}${formatDimText("This is a dry run. No changes were applied.")}`);
+  lines.push(`${prefix}${formatDimText("Run without --plan to apply changes.")}`);
+  return lines.join("\n");
+}
+function formatDbInitApplyOutput(result, flags) {
+  if (flags.quiet) {
+    return "";
+  }
+  const lines = [];
+  const prefix = createPrefix(flags);
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  const formatDimText = (text) => formatDim(useColor, text);
+  if (result.ok) {
+    const executed = result.execution?.operationsExecuted ?? 0;
+    lines.push(`${prefix}${formatGreen("\u2714")} Applied ${executed} operation(s)`);
+    if (result.marker) {
+      lines.push(`${prefix}${formatDimText(`  Marker written: ${result.marker.coreHash}`)}`);
+      if (result.marker.profileHash) {
+        lines.push(`${prefix}${formatDimText(`  Profile hash: ${result.marker.profileHash}`)}`);
+      }
+    }
+    if (isVerbose(flags, 1)) {
+      lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatDbInitJson(result) {
+  return JSON.stringify(result, null, 2);
+}
 var LEFT_COLUMN_WIDTH = 20;
 var RIGHT_COLUMN_MIN_WIDTH = 40;
 var RIGHT_COLUMN_MAX_WIDTH = 90;
@@ -908,44 +1040,6 @@ function formatRootHelp(options) {
 `;
 }
 
-// src/utils/cli-errors.ts
-import {
-  CliStructuredError,
-  errorConfigFileNotFound as errorConfigFileNotFound2,
-  errorConfigValidation,
-  errorContractConfigMissing,
-  errorContractValidationFailed,
-  errorDatabaseUrlRequired,
-  errorDriverRequired,
-  errorFamilyReadMarkerSqlRequired,
-  errorFileNotFound,
-  errorHashMismatch,
-  errorMarkerMissing,
-  errorQueryRunnerFactoryRequired,
-  errorRuntime,
-  errorTargetMismatch,
-  errorUnexpected as errorUnexpected2
-} from "@prisma-next/core-control-plane/errors";
-
-// src/utils/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-async function performAction(fn) {
-  try {
-    const value = await fn();
-    return ok(value);
-  } catch (error) {
-    if (error instanceof CliStructuredError) {
-      return err(error);
-    }
-    throw error;
-  }
-}
-
 // src/utils/result-handler.ts
 function handleResult(result, flags, onSuccess) {
   if (result.ok) {
@@ -954,59 +1048,36 @@ function handleResult(result, flags, onSuccess) {
     }
     return 0;
   }
-  const envelope = result.error.toEnvelope();
-  if (flags.json === "object") {
+  const envelope = result.failure.toEnvelope();
+  if (flags.json) {
     console.error(formatErrorJson(envelope));
   } else {
     console.error(formatErrorOutput(envelope, flags));
   }
-  const exitCode = result.error.domain === "CLI" ? 2 : 1;
+  const exitCode = result.failure.domain === "CLI" ? 2 : 1;
   return exitCode;
 }
 
 // src/utils/spinner.ts
 import ora from "ora";
 async function withSpinner(operation, options) {
-  const { message, flags, delayThreshold = 100 } = options;
+  const { message, flags } = options;
   const shouldShowSpinner = !flags.quiet && flags.json !== "object" && process.stdout.isTTY;
   if (!shouldShowSpinner) {
     return operation();
   }
   const startTime = Date.now();
-  let spinner = null;
-  let timeoutId = null;
-  let operationCompleted = false;
-  timeoutId = setTimeout(() => {
-    if (!operationCompleted) {
-      spinner = ora({
-        text: message,
-        color: flags.color !== false ? "cyan" : false
-      }).start();
-    }
-  }, delayThreshold);
+  const spinner = ora({
+    text: message,
+    color: flags.color !== false ? "cyan" : false
+  }).start();
   try {
     const result = await operation();
-    operationCompleted = true;
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-    if (spinner !== null) {
-      const elapsed = Date.now() - startTime;
-      spinner.succeed(`${message} (${elapsed}ms)`);
-    }
+    const elapsed = Date.now() - startTime;
+    spinner.succeed(`${message} (${elapsed}ms)`);
     return result;
   } catch (error) {
-    operationCompleted = true;
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-    if (spinner !== null) {
-      spinner.fail(
-        `${message} failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
+    spinner.fail(`${message} failed: ${error instanceof Error ? error.message : String(error)}`);
     throw error;
   }
 }
@@ -1067,7 +1138,7 @@ function createContractEmitCommand() {
         target: config.target,
         adapter: config.adapter,
         driver: config.driver,
-        extensions: config.extensions ?? []
+        extensionPacks: config.extensionPacks ?? []
       });
       let contractRaw;
       if (typeof contractConfig.source === "function") {
@@ -1121,18 +1192,413 @@ function createContractEmitCommand() {
   return command;
 }
 
-// src/commands/db-introspect.ts
+// src/commands/db-init.ts
 import { readFile } from "fs/promises";
 import { relative as relative3, resolve as resolve3 } from "path";
+import { redactDatabaseUrl } from "@prisma-next/utils/redact-db-url";
+import { Command as Command2 } from "commander";
+
+// src/utils/framework-components.ts
+import {
+  checkContractComponentRequirements
+} from "@prisma-next/contract/framework-components";
+function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId, frameworkComponents) {
+  for (let i = 0; i < frameworkComponents.length; i++) {
+    const component = frameworkComponents[i];
+    if (typeof component !== "object" || component === null) {
+      throw errorConfigValidation("frameworkComponents[]", {
+        why: `Framework component at index ${i} must be an object`
+      });
+    }
+    const record = component;
+    if (!Object.hasOwn(record, "kind")) {
+      throw errorConfigValidation("frameworkComponents[].kind", {
+        why: `Framework component at index ${i} must have 'kind' property`
+      });
+    }
+    const kind = record["kind"];
+    if (kind !== "target" && kind !== "adapter" && kind !== "extension" && kind !== "driver") {
+      throw errorConfigValidation("frameworkComponents[].kind", {
+        why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')`
+      });
+    }
+    if (!Object.hasOwn(record, "familyId")) {
+      throw errorConfigValidation("frameworkComponents[].familyId", {
+        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property`
+      });
+    }
+    const familyId = record["familyId"];
+    if (familyId !== expectedFamilyId) {
+      throw errorConfigValidation("frameworkComponents[].familyId", {
+        why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'`
+      });
+    }
+    if (!Object.hasOwn(record, "targetId")) {
+      throw errorConfigValidation("frameworkComponents[].targetId", {
+        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property`
+      });
+    }
+    const targetId = record["targetId"];
+    if (targetId !== expectedTargetId) {
+      throw errorConfigValidation("frameworkComponents[].targetId", {
+        why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'`
+      });
+    }
+  }
+  return frameworkComponents;
+}
+function assertContractRequirementsSatisfied({
+  contract,
+  family,
+  target,
+  adapter,
+  extensionPacks
+}) {
+  const providedComponentIds = /* @__PURE__ */ new Set([target.id, adapter.id]);
+  for (const extension of extensionPacks ?? []) {
+    providedComponentIds.add(extension.id);
+  }
+  const result = checkContractComponentRequirements({
+    contract,
+    expectedTargetFamily: family.familyId,
+    expectedTargetId: target.targetId,
+    providedComponentIds
+  });
+  if (result.familyMismatch) {
+    throw errorConfigValidation("contract.targetFamily", {
+      why: `Contract was emitted for family '${result.familyMismatch.actual}' but CLI config is wired to '${result.familyMismatch.expected}'.`
+    });
+  }
+  if (result.targetMismatch) {
+    throw errorConfigValidation("contract.target", {
+      why: `Contract target '${result.targetMismatch.actual}' does not match CLI target '${result.targetMismatch.expected}'.`
+    });
+  }
+  if (result.missingExtensionPackIds.length > 0) {
+    throw errorContractMissingExtensionPacks({
+      missingExtensionPacks: result.missingExtensionPackIds,
+      providedComponentIds: [...providedComponentIds]
+    });
+  }
+}
+
+// src/commands/db-init.ts
+function createDbInitCommand() {
+  const command = new Command2("init");
+  setCommandDescriptions(
+    command,
+    "Bootstrap a database to match the current contract and write the contract marker",
+    "Initializes a database to match your emitted contract using additive-only operations.\nCreates any missing tables, columns, indexes, and constraints defined in your contract.\nLeaves existing compatible structures in place, surfaces conflicts when destructive changes\nwould be required, and writes a contract marker to track the database state. Use --plan to\npreview changes without applying."
+  );
+  command.configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    }
+  }).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--plan", "Preview planned operations without applying", false).option("--json [format]", "Output as JSON (object)", false).option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("-vv, --trace", "Trace output: deep internals, stack traces").option("--timestamps", "Add timestamps to output").option("--color", "Force color output").option("--no-color", "Disable color output").action(async (options) => {
+    const flags = parseGlobalFlags(options);
+    const startTime = Date.now();
+    const result = await performAction(async () => {
+      if (flags.json === "ndjson") {
+        throw errorJsonFormatNotSupported({
+          command: "db init",
+          format: "ndjson",
+          supportedFormats: ["object"]
+        });
+      }
+      const config = await loadConfig(options.config);
+      const configPath = options.config ? relative3(process.cwd(), resolve3(options.config)) : "prisma-next.config.ts";
+      const contractPathAbsolute = config.contract?.output ? resolve3(config.contract.output) : resolve3("src/prisma/contract.json");
+      const contractPath = relative3(process.cwd(), contractPathAbsolute);
+      if (flags.json !== "object" && !flags.quiet) {
+        const details = [
+          { label: "config", value: configPath },
+          { label: "contract", value: contractPath }
+        ];
+        if (options.db) {
+          details.push({ label: "database", value: options.db });
+        }
+        if (options.plan) {
+          details.push({ label: "mode", value: "plan (dry run)" });
+        }
+        const header = formatStyledHeader({
+          command: "db init",
+          description: "Bootstrap a database to match the current contract",
+          url: "https://pris.ly/db-init",
+          details,
+          flags
+        });
+        console.log(header);
+      }
+      let contractJsonContent;
+      try {
+        contractJsonContent = await readFile(contractPathAbsolute, "utf-8");
+      } catch (error) {
+        if (error instanceof Error && error.code === "ENOENT") {
+          throw errorFileNotFound(contractPathAbsolute, {
+            why: `Contract file not found at ${contractPathAbsolute}`,
+            fix: `Run \`prisma-next contract emit\` to generate ${contractPath}, or update \`config.contract.output\` in ${configPath}`
+          });
+        }
+        throw errorUnexpected2(error instanceof Error ? error.message : String(error), {
+          why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+      let contractJson;
+      try {
+        contractJson = JSON.parse(contractJsonContent);
+      } catch (error) {
+        throw errorContractValidationFailed(
+          `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,
+          { where: { path: contractPathAbsolute } }
+        );
+      }
+      const dbUrl = options.db ?? config.db?.url;
+      if (!dbUrl) {
+        throw errorDatabaseUrlRequired({
+          why: `Database URL is required for db init (set db.url in ${configPath}, or pass --db <url>)`
+        });
+      }
+      if (!config.driver) {
+        throw errorDriverRequired({ why: "Config.driver is required for db init" });
+      }
+      const driverDescriptor = config.driver;
+      if (!config.target.migrations) {
+        throw errorTargetMigrationNotSupported({
+          why: `Target "${config.target.id}" does not support migrations`
+        });
+      }
+      const migrations = config.target.migrations;
+      let driver;
+      try {
+        driver = await withSpinner(() => driverDescriptor.create(dbUrl), {
+          message: "Connecting to database...",
+          flags
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = error.code;
+        const redacted = redactDatabaseUrl(dbUrl);
+        throw errorRuntime("Database connection failed", {
+          why: message,
+          fix: "Verify the database URL, ensure the database is reachable, and confirm credentials/permissions",
+          meta: {
+            ...typeof code !== "undefined" ? { code } : {},
+            ...redacted
+          }
+        });
+      }
+      try {
+        const familyInstance = config.family.create({
+          target: config.target,
+          adapter: config.adapter,
+          driver: driverDescriptor,
+          extensionPacks: config.extensionPacks ?? []
+        });
+        const rawComponents = [config.target, config.adapter, ...config.extensionPacks ?? []];
+        const frameworkComponents = assertFrameworkComponentsCompatible(
+          config.family.familyId,
+          config.target.targetId,
+          rawComponents
+        );
+        const contractIR = familyInstance.validateContractIR(contractJson);
+        assertContractRequirementsSatisfied({
+          contract: contractIR,
+          family: config.family,
+          target: config.target,
+          adapter: config.adapter,
+          extensionPacks: config.extensionPacks
+        });
+        const planner = migrations.createPlanner(familyInstance);
+        const runner = migrations.createRunner(familyInstance);
+        const schemaIR = await withSpinner(() => familyInstance.introspect({ driver }), {
+          message: "Introspecting database schema...",
+          flags
+        });
+        const policy = { allowedOperationClasses: ["additive"] };
+        const plannerResult = await withSpinner(
+          async () => planner.plan({
+            contract: contractIR,
+            schema: schemaIR,
+            policy,
+            frameworkComponents
+          }),
+          {
+            message: "Planning migration...",
+            flags
+          }
+        );
+        if (plannerResult.kind === "failure") {
+          throw errorMigrationPlanningFailed({ conflicts: plannerResult.conflicts });
+        }
+        const migrationPlan = plannerResult.plan;
+        const existingMarker = await familyInstance.readMarker({ driver });
+        if (existingMarker) {
+          const markerMatchesDestination = existingMarker.coreHash === migrationPlan.destination.coreHash && (!migrationPlan.destination.profileHash || existingMarker.profileHash === migrationPlan.destination.profileHash);
+          if (markerMatchesDestination) {
+            const dbInitResult2 = {
+              ok: true,
+              mode: options.plan ? "plan" : "apply",
+              plan: {
+                targetId: migrationPlan.targetId,
+                destination: migrationPlan.destination,
+                operations: []
+              },
+              ...options.plan ? {} : {
+                execution: { operationsPlanned: 0, operationsExecuted: 0 },
+                marker: {
+                  coreHash: existingMarker.coreHash,
+                  profileHash: existingMarker.profileHash
+                }
+              },
+              summary: "Database already at target contract state",
+              timings: { total: Date.now() - startTime }
+            };
+            return dbInitResult2;
+          }
+          const coreHashMismatch = existingMarker.coreHash !== migrationPlan.destination.coreHash;
+          const profileHashMismatch = migrationPlan.destination.profileHash && existingMarker.profileHash !== migrationPlan.destination.profileHash;
+          const mismatchParts = [];
+          if (coreHashMismatch) {
+            mismatchParts.push(
+              `coreHash (marker: ${existingMarker.coreHash}, destination: ${migrationPlan.destination.coreHash})`
+            );
+          }
+          if (profileHashMismatch) {
+            mismatchParts.push(
+              `profileHash (marker: ${existingMarker.profileHash}, destination: ${migrationPlan.destination.profileHash})`
+            );
+          }
+          throw errorRuntime(
+            `Existing contract marker does not match plan destination. Mismatch in ${mismatchParts.join(" and ")}.`,
+            {
+              why: "Database has an existing contract marker that does not match the target contract",
+              fix: "If bootstrapping, drop/reset the database then re-run `prisma-next db init`; otherwise reconcile schema/marker using your migration workflow",
+              meta: {
+                code: "MARKER_ORIGIN_MISMATCH",
+                markerCoreHash: existingMarker.coreHash,
+                destinationCoreHash: migrationPlan.destination.coreHash,
+                ...existingMarker.profileHash ? { markerProfileHash: existingMarker.profileHash } : {},
+                ...migrationPlan.destination.profileHash ? { destinationProfileHash: migrationPlan.destination.profileHash } : {}
+              }
+            }
+          );
+        }
+        if (options.plan) {
+          const dbInitResult2 = {
+            ok: true,
+            mode: "plan",
+            plan: {
+              targetId: migrationPlan.targetId,
+              destination: migrationPlan.destination,
+              operations: migrationPlan.operations.map((op) => ({
+                id: op.id,
+                label: op.label,
+                operationClass: op.operationClass
+              }))
+            },
+            summary: `Planned ${migrationPlan.operations.length} operation(s)`,
+            timings: { total: Date.now() - startTime }
+          };
+          return dbInitResult2;
+        }
+        if (!flags.quiet && flags.json !== "object") {
+          console.log("Applying migration plan and verifying schema...");
+        }
+        const callbacks = {
+          onOperationStart: (op) => {
+            if (!flags.quiet && flags.json !== "object") {
+              console.log(`  \u2192 ${op.label}...`);
+            }
+          },
+          onOperationComplete: (_op) => {
+          }
+        };
+        const runnerResult = await runner.execute({
+          plan: migrationPlan,
+          driver,
+          destinationContract: contractIR,
+          policy,
+          callbacks,
+          // db init plans and applies back-to-back from a fresh introspection, so per-operation
+          // pre/postchecks and the idempotency probe are usually redundant overhead. We still
+          // enforce marker/origin compatibility and a full schema verification after apply.
+          executionChecks: {
+            prechecks: false,
+            postchecks: false,
+            idempotencyChecks: false
+          },
+          frameworkComponents
+        });
+        if (!runnerResult.ok) {
+          const meta = {
+            code: runnerResult.failure.code,
+            ...runnerResult.failure.meta ?? {}
+          };
+          const sqlState = typeof meta["sqlState"] === "string" ? meta["sqlState"] : void 0;
+          const fix = sqlState === "42501" ? "Grant the database user sufficient privileges (insufficient_privilege), or run db init as a more privileged role" : runnerResult.failure.code === "SCHEMA_VERIFY_FAILED" ? "Fix the schema mismatch (db init is additive-only), or drop/reset the database and re-run `prisma-next db init`" : void 0;
+          throw errorRuntime(runnerResult.failure.summary, {
+            why: runnerResult.failure.why ?? `Migration runner failed: ${runnerResult.failure.code}`,
+            ...fix ? { fix } : {},
+            meta
+          });
+        }
+        const execution = runnerResult.value;
+        const dbInitResult = {
+          ok: true,
+          mode: "apply",
+          plan: {
+            targetId: migrationPlan.targetId,
+            destination: migrationPlan.destination,
+            operations: migrationPlan.operations.map((op) => ({
+              id: op.id,
+              label: op.label,
+              operationClass: op.operationClass
+            }))
+          },
+          execution: {
+            operationsPlanned: execution.operationsPlanned,
+            operationsExecuted: execution.operationsExecuted
+          },
+          marker: migrationPlan.destination.profileHash ? {
+            coreHash: migrationPlan.destination.coreHash,
+            profileHash: migrationPlan.destination.profileHash
+          } : { coreHash: migrationPlan.destination.coreHash },
+          summary: `Applied ${execution.operationsExecuted} operation(s), marker written`,
+          timings: { total: Date.now() - startTime }
+        };
+        return dbInitResult;
+      } finally {
+        await driver.close();
+      }
+    });
+    const exitCode = handleResult(result, flags, (dbInitResult) => {
+      if (flags.json === "object") {
+        console.log(formatDbInitJson(dbInitResult));
+      } else {
+        const output = dbInitResult.mode === "plan" ? formatDbInitPlanOutput(dbInitResult, flags) : formatDbInitApplyOutput(dbInitResult, flags);
+        if (output) {
+          console.log(output);
+        }
+      }
+    });
+    process.exit(exitCode);
+  });
+  return command;
+}
+
+// src/commands/db-introspect.ts
+import { readFile as readFile2 } from "fs/promises";
+import { relative as relative4, resolve as resolve4 } from "path";
 import {
   errorDatabaseUrlRequired as errorDatabaseUrlRequired2,
   errorDriverRequired as errorDriverRequired2,
   errorRuntime as errorRuntime2,
   errorUnexpected as errorUnexpected3
 } from "@prisma-next/core-control-plane/errors";
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 function createDbIntrospectCommand() {
-  const command = new Command2("introspect");
+  const command = new Command3("introspect");
   setCommandDescriptions(
     command,
     "Inspect the database schema",
@@ -1148,14 +1614,13 @@ function createDbIntrospectCommand() {
     const result = await performAction(async () => {
       const startTime = Date.now();
       const config = await loadConfig(options.config);
-      const configPath = options.config ? relative3(process.cwd(), resolve3(options.config)) : "prisma-next.config.ts";
+      const configPath = options.config ? relative4(process.cwd(), resolve4(options.config)) : "prisma-next.config.ts";
       let contractIR;
       if (config.contract?.output) {
-        const contractPath = resolve3(config.contract.output);
+        const contractPath = resolve4(config.contract.output);
         try {
-          const contractJsonContent = await readFile(contractPath, "utf-8");
-          const contractJson = JSON.parse(contractJsonContent);
-          contractIR = contractJson;
+          const contractJsonContent = await readFile2(contractPath, "utf-8");
+          contractIR = JSON.parse(contractJsonContent);
         } catch (error) {
           if (error instanceof Error && error.code !== "ENOENT") {
             throw errorUnexpected3(error.message, {
@@ -1201,16 +1666,23 @@ function createDbIntrospectCommand() {
           target: config.target,
           adapter: config.adapter,
           driver: driverDescriptor,
-          extensions: config.extensions ?? []
+          extensionPacks: config.extensionPacks ?? []
         });
-        const typedFamilyInstance = familyInstance;
         if (contractIR) {
-          contractIR = typedFamilyInstance.validateContractIR(contractIR);
+          const validatedContract = familyInstance.validateContractIR(contractIR);
+          assertContractRequirementsSatisfied({
+            contract: validatedContract,
+            family: config.family,
+            target: config.target,
+            adapter: config.adapter,
+            extensionPacks: config.extensionPacks
+          });
+          contractIR = validatedContract;
         }
         let schemaIR;
         try {
           schemaIR = await withSpinner(
-            () => typedFamilyInstance.introspect({
+            () => familyInstance.introspect({
               driver,
               contractIR
             }),
@@ -1225,9 +1697,9 @@ function createDbIntrospectCommand() {
           });
         }
         let schemaView;
-        if (typedFamilyInstance.toSchemaView) {
+        if (familyInstance.toSchemaView) {
           try {
-            schemaView = typedFamilyInstance.toSchemaView(schemaIR);
+            schemaView = familyInstance.toSchemaView(schemaIR);
           } catch (error) {
             if (flags.verbose) {
               console.error(
@@ -1285,8 +1757,8 @@ function createDbIntrospectCommand() {
 }
 
 // src/commands/db-schema-verify.ts
-import { readFile as readFile2 } from "fs/promises";
-import { relative as relative4, resolve as resolve4 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { relative as relative5, resolve as resolve5 } from "path";
 import {
   errorDatabaseUrlRequired as errorDatabaseUrlRequired3,
   errorDriverRequired as errorDriverRequired3,
@@ -1294,9 +1766,9 @@ import {
   errorRuntime as errorRuntime3,
   errorUnexpected as errorUnexpected4
 } from "@prisma-next/core-control-plane/errors";
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 function createDbSchemaVerifyCommand() {
-  const command = new Command3("schema-verify");
+  const command = new Command4("schema-verify");
   setCommandDescriptions(
     command,
     "Check whether the database schema satisfies your contract",
@@ -1311,9 +1783,9 @@ function createDbSchemaVerifyCommand() {
     const flags = parseGlobalFlags(options);
     const result = await performAction(async () => {
       const config = await loadConfig(options.config);
-      const configPath = options.config ? relative4(process.cwd(), resolve4(options.config)) : "prisma-next.config.ts";
-      const contractPathAbsolute = config.contract?.output ? resolve4(config.contract.output) : resolve4("src/prisma/contract.json");
-      const contractPath = relative4(process.cwd(), contractPathAbsolute);
+      const configPath = options.config ? relative5(process.cwd(), resolve5(options.config)) : "prisma-next.config.ts";
+      const contractPathAbsolute = config.contract?.output ? resolve5(config.contract.output) : resolve5("src/prisma/contract.json");
+      const contractPath = relative5(process.cwd(), contractPathAbsolute);
       if (flags.json !== "object" && !flags.quiet) {
         const details = [
           { label: "config", value: configPath },
@@ -1333,7 +1805,7 @@ function createDbSchemaVerifyCommand() {
       }
       let contractJsonContent;
       try {
-        contractJsonContent = await readFile2(contractPathAbsolute, "utf-8");
+        contractJsonContent = await readFile3(contractPathAbsolute, "utf-8");
       } catch (error) {
         if (error instanceof Error && error.code === "ENOENT") {
           throw errorFileNotFound2(contractPathAbsolute, {
@@ -1345,36 +1817,49 @@ function createDbSchemaVerifyCommand() {
         });
       }
       const contractJson = JSON.parse(contractJsonContent);
-      const dbUrl = options.db ?? config.db?.url;
-      if (!dbUrl) {
-        throw errorDatabaseUrlRequired3();
-      }
       if (!config.driver) {
         throw errorDriverRequired3();
       }
       const driverDescriptor = config.driver;
+      const familyInstance = config.family.create({
+        target: config.target,
+        adapter: config.adapter,
+        driver: driverDescriptor,
+        extensionPacks: config.extensionPacks ?? []
+      });
+      const contractIR = familyInstance.validateContractIR(contractJson);
+      assertContractRequirementsSatisfied({
+        contract: contractIR,
+        family: config.family,
+        target: config.target,
+        adapter: config.adapter,
+        extensionPacks: config.extensionPacks
+      });
+      const dbUrl = options.db ?? config.db?.url;
+      if (!dbUrl) {
+        throw errorDatabaseUrlRequired3();
+      }
       const driver = await withSpinner(() => driverDescriptor.create(dbUrl), {
         message: "Connecting to database...",
         flags
       });
       try {
-        const familyInstance = config.family.create({
-          target: config.target,
-          adapter: config.adapter,
-          driver: driverDescriptor,
-          extensions: config.extensions ?? []
-        });
-        const typedFamilyInstance = familyInstance;
-        const contractIR = typedFamilyInstance.validateContractIR(contractJson);
+        const rawComponents = [config.target, config.adapter, ...config.extensionPacks ?? []];
+        const frameworkComponents = assertFrameworkComponentsCompatible(
+          config.family.familyId,
+          config.target.targetId,
+          rawComponents
+        );
         let schemaVerifyResult;
         try {
           schemaVerifyResult = await withSpinner(
-            () => typedFamilyInstance.schemaVerify({
+            () => familyInstance.schemaVerify({
               driver,
               contractIR,
               strict: options.strict ?? false,
               contractPath: contractPathAbsolute,
-              configPath
+              configPath,
+              frameworkComponents
             }),
             {
               message: "Verifying database schema...",
@@ -1414,8 +1899,8 @@ function createDbSchemaVerifyCommand() {
 }
 
 // src/commands/db-sign.ts
-import { readFile as readFile3 } from "fs/promises";
-import { relative as relative5, resolve as resolve5 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { relative as relative6, resolve as resolve6 } from "path";
 import {
   errorDatabaseUrlRequired as errorDatabaseUrlRequired4,
   errorDriverRequired as errorDriverRequired4,
@@ -1423,9 +1908,9 @@ import {
   errorRuntime as errorRuntime4,
   errorUnexpected as errorUnexpected5
 } from "@prisma-next/core-control-plane/errors";
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 function createDbSignCommand() {
-  const command = new Command4("sign");
+  const command = new Command5("sign");
   setCommandDescriptions(
     command,
     "Sign the database with your contract so you can safely run queries",
@@ -1440,9 +1925,9 @@ function createDbSignCommand() {
     const flags = parseGlobalFlags(options);
     const result = await performAction(async () => {
       const config = await loadConfig(options.config);
-      const configPath = options.config ? relative5(process.cwd(), resolve5(options.config)) : "prisma-next.config.ts";
-      const contractPathAbsolute = config.contract?.output ? resolve5(config.contract.output) : resolve5("src/prisma/contract.json");
-      const contractPath = relative5(process.cwd(), contractPathAbsolute);
+      const configPath = options.config ? relative6(process.cwd(), resolve6(options.config)) : "prisma-next.config.ts";
+      const contractPathAbsolute = config.contract?.output ? resolve6(config.contract.output) : resolve6("src/prisma/contract.json");
+      const contractPath = relative6(process.cwd(), contractPathAbsolute);
       if (flags.json !== "object" && !flags.quiet) {
         const details = [
           { label: "config", value: configPath },
@@ -1462,7 +1947,7 @@ function createDbSignCommand() {
       }
       let contractJsonContent;
       try {
-        contractJsonContent = await readFile3(contractPathAbsolute, "utf-8");
+        contractJsonContent = await readFile4(contractPathAbsolute, "utf-8");
       } catch (error) {
         if (error instanceof Error && error.code === "ENOENT") {
           throw errorFileNotFound3(contractPathAbsolute, {
@@ -1482,28 +1967,39 @@ function createDbSignCommand() {
         throw errorDriverRequired4();
       }
       const driverDescriptor = config.driver;
+      const familyInstance = config.family.create({
+        target: config.target,
+        adapter: config.adapter,
+        driver: driverDescriptor,
+        extensionPacks: config.extensionPacks ?? []
+      });
+      const contractIR = familyInstance.validateContractIR(contractJson);
+      assertContractRequirementsSatisfied({
+        contract: contractIR,
+        family: config.family,
+        target: config.target,
+        adapter: config.adapter,
+        extensionPacks: config.extensionPacks
+      });
+      const rawComponents = [config.target, config.adapter, ...config.extensionPacks ?? []];
+      const frameworkComponents = assertFrameworkComponentsCompatible(
+        config.family.familyId,
+        config.target.targetId,
+        rawComponents
+      );
       const driver = await driverDescriptor.create(dbUrl);
       try {
-        const familyInstance = config.family.create({
-          target: config.target,
-          adapter: config.adapter,
-          driver: driverDescriptor,
-          extensions: config.extensions ?? []
-        });
-        const typedFamilyInstance = familyInstance;
-        const contractIR = typedFamilyInstance.validateContractIR(contractJson);
         let schemaVerifyResult;
         try {
           schemaVerifyResult = await withSpinner(
-            async () => {
-              return await typedFamilyInstance.schemaVerify({
-                driver,
-                contractIR,
-                strict: false,
-                contractPath: contractPathAbsolute,
-                configPath
-              });
-            },
+            () => familyInstance.schemaVerify({
+              driver,
+              contractIR,
+              strict: false,
+              contractPath: contractPathAbsolute,
+              configPath,
+              frameworkComponents
+            }),
             {
               message: "Verifying database satisfies contract",
               flags
@@ -1520,14 +2016,12 @@ function createDbSignCommand() {
         let signResult;
         try {
           signResult = await withSpinner(
-            async () => {
-              return await typedFamilyInstance.sign({
-                driver,
-                contractIR,
-                contractPath: contractPathAbsolute,
-                configPath
-              });
-            },
+            () => familyInstance.sign({
+              driver,
+              contractIR,
+              contractPath: contractPathAbsolute,
+              configPath
+            }),
             {
               message: "Signing database...",
               flags
@@ -1580,8 +2074,8 @@ function createDbSignCommand() {
 }
 
 // src/commands/db-verify.ts
-import { readFile as readFile4 } from "fs/promises";
-import { relative as relative6, resolve as resolve6 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { relative as relative7, resolve as resolve7 } from "path";
 import {
   errorDatabaseUrlRequired as errorDatabaseUrlRequired5,
   errorDriverRequired as errorDriverRequired5,
@@ -1592,9 +2086,9 @@ import {
   errorTargetMismatch as errorTargetMismatch2,
   errorUnexpected as errorUnexpected6
 } from "@prisma-next/core-control-plane/errors";
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 function createDbVerifyCommand() {
-  const command = new Command5("verify");
+  const command = new Command6("verify");
   setCommandDescriptions(
     command,
     "Check whether the database has been signed with your contract",
@@ -1609,9 +2103,9 @@ function createDbVerifyCommand() {
     const flags = parseGlobalFlags(options);
     const result = await performAction(async () => {
       const config = await loadConfig(options.config);
-      const configPath = options.config ? relative6(process.cwd(), resolve6(options.config)) : "prisma-next.config.ts";
-      const contractPathAbsolute = config.contract?.output ? resolve6(config.contract.output) : resolve6("src/prisma/contract.json");
-      const contractPath = relative6(process.cwd(), contractPathAbsolute);
+      const configPath = options.config ? relative7(process.cwd(), resolve7(options.config)) : "prisma-next.config.ts";
+      const contractPathAbsolute = config.contract?.output ? resolve7(config.contract.output) : resolve7("src/prisma/contract.json");
+      const contractPath = relative7(process.cwd(), contractPathAbsolute);
       if (flags.json !== "object" && !flags.quiet) {
         const details = [
           { label: "config", value: configPath },
@@ -1631,7 +2125,7 @@ function createDbVerifyCommand() {
       }
       let contractJsonContent;
       try {
-        contractJsonContent = await readFile4(contractPathAbsolute, "utf-8");
+        contractJsonContent = await readFile5(contractPathAbsolute, "utf-8");
       } catch (error) {
         if (error instanceof Error && error.code === "ENOENT") {
           throw errorFileNotFound4(contractPathAbsolute, {
@@ -1660,14 +2154,20 @@ function createDbVerifyCommand() {
           target: config.target,
           adapter: config.adapter,
           driver: driverDescriptor,
-          extensions: config.extensions ?? []
+          extensionPacks: config.extensionPacks ?? []
+        });
+        const contractIR = familyInstance.validateContractIR(contractJson);
+        assertContractRequirementsSatisfied({
+          contract: contractIR,
+          family: config.family,
+          target: config.target,
+          adapter: config.adapter,
+          extensionPacks: config.extensionPacks
         });
-        const typedFamilyInstance = familyInstance;
-        const contractIR = typedFamilyInstance.validateContractIR(contractJson);
         let verifyResult;
         try {
           verifyResult = await withSpinner(
-            () => typedFamilyInstance.verify({
+            () => familyInstance.verify({
               driver,
               contractIR,
               expectedTargetId: config.target.targetId,
@@ -1726,7 +2226,7 @@ function createDbVerifyCommand() {
 }
 
 // src/cli.ts
-var program = new Command6();
+var program = new Command7();
 program.name("prisma-next").description("Prisma Next CLI").version("0.0.1");
 var versionOption = program.options.find((opt) => opt.flags.includes("--version"));
 if (versionOption) {
@@ -1746,11 +2246,11 @@ program.configureHelp({
   formatHelp: rootHelpFormatter,
   subcommandDescription: () => ""
 });
-program.exitOverride((err2) => {
-  if (err2) {
-    const errorCode = err2.code;
-    const errorMessage = String(err2.message ?? "");
-    const errorName = err2.name ?? "";
+program.exitOverride((err) => {
+  if (err) {
+    const errorCode = err.code;
+    const errorMessage = String(err.message ?? "");
+    const errorName = err.name ?? "";
     const isUnknownCommandError = errorCode === "commander.unknownCommand" || errorCode === "commander.unknownArgument" || errorName === "CommanderError" && (errorMessage.includes("unknown command") || errorMessage.includes("unknown argument"));
     if (isUnknownCommandError) {
       const flags = parseGlobalFlags({});
@@ -1782,15 +2282,15 @@ program.exitOverride((err2) => {
       process.exit(0);
       return;
     }
-    console.error(`Unhandled error: ${err2.message}`);
-    if (err2.stack) {
-      console.error(err2.stack);
+    console.error(`Unhandled error: ${err.message}`);
+    if (err.stack) {
+      console.error(err.stack);
     }
     process.exit(1);
   }
   process.exit(0);
 });
-var contractCommand = new Command6("contract");
+var contractCommand = new Command7("contract");
 setCommandDescriptions(
   contractCommand,
   "Contract management commands",
@@ -1806,7 +2306,7 @@ contractCommand.configureHelp({
 var contractEmitCommand = createContractEmitCommand();
 contractCommand.addCommand(contractEmitCommand);
 program.addCommand(contractCommand);
-var dbCommand = new Command6("db");
+var dbCommand = new Command7("db");
 setCommandDescriptions(
   dbCommand,
   "Database management commands",
@@ -1821,6 +2321,8 @@ dbCommand.configureHelp({
 });
 var dbVerifyCommand = createDbVerifyCommand();
 dbCommand.addCommand(dbVerifyCommand);
+var dbInitCommand = createDbInitCommand();
+dbCommand.addCommand(dbInitCommand);
 var dbIntrospectCommand = createDbIntrospectCommand();
 dbCommand.addCommand(dbIntrospectCommand);
 var dbSchemaVerifyCommand = createDbSchemaVerifyCommand();
@@ -1828,7 +2330,7 @@ dbCommand.addCommand(dbSchemaVerifyCommand);
 var dbSignCommand = createDbSignCommand();
 dbCommand.addCommand(dbSignCommand);
 program.addCommand(dbCommand);
-var helpCommand = new Command6("help").description("Show usage instructions").configureHelp({
+var helpCommand = new Command7("help").description("Show usage instructions").configureHelp({
   formatHelp: (cmd) => {
     const flags = parseGlobalFlags({});
     return formatCommandHelp({ command: cmd, flags });