@prisma-next/cli 0.3.0-dev.14 → 0.3.0-dev.16

package/dist/commands/contract-emit.js

@@ -1,7 +1,8 @@
 import {
   createContractEmitCommand
-} from "../chunk-MG7PBERL.js";
-import "../chunk-DIJPT5TZ.js";
+} from "../chunk-U6QI3AZ3.js";
+import "../chunk-5MPKZYVI.js";
+import "../chunk-ZG5T6OB5.js";
 import "../chunk-HWYQOCAJ.js";
 import "../chunk-VI2YETW7.js";
 export {

package/dist/commands/db-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db-init.d.ts","sourceRoot":"","sources":["../../src/commands/db-init.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+CpC,wBAAgB,mBAAmB,IAAI,OAAO,CA2Y7C"}
+{"version":3,"file":"db-init.d.ts","sourceRoot":"","sources":["../../src/commands/db-init.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmSpC,wBAAgB,mBAAmB,IAAI,OAAO,CAiE7C"}

package/dist/commands/db-init.js

@@ -1,7 +1,7 @@
 import {
-  assertContractRequirementsSatisfied,
-  assertFrameworkComponentsCompatible
-} from "../chunk-6EPKRATC.js";
+  createControlClient
+} from "../chunk-74IELXRA.js";
+import "../chunk-6EPKRATC.js";
 import {
   formatCommandHelp,
   formatDbInitApplyOutput,
@@ -10,14 +10,13 @@ import {
   formatStyledHeader,
   handleResult,
   parseGlobalFlags,
-  performAction,
-  setCommandDescriptions,
-  withSpinner
-} from "../chunk-DIJPT5TZ.js";
+  setCommandDescriptions
+} from "../chunk-ZG5T6OB5.js";
 import {
   loadConfig
 } from "../chunk-HWYQOCAJ.js";
 import {
+  CliStructuredError,
   errorContractValidationFailed,
   errorDatabaseConnectionRequired,
   errorDriverRequired,
@@ -32,9 +31,230 @@ import {
 // src/commands/db-init.ts
 import { readFile } from "fs/promises";
 import { relative, resolve } from "path";
-import { createControlPlaneStack } from "@prisma-next/core-control-plane/types";
-import { redactDatabaseUrl } from "@prisma-next/utils/redact-db-url";
+import { notOk, ok } from "@prisma-next/utils/result";
 import { Command } from "commander";
+
+// src/utils/progress-adapter.ts
+import ora from "ora";
+function createProgressAdapter(options) {
+  const { flags } = options;
+  const shouldShowProgress = !flags.quiet && flags.json !== "object" && process.stdout.isTTY;
+  if (!shouldShowProgress) {
+    return () => {
+    };
+  }
+  const activeSpans = /* @__PURE__ */ new Map();
+  return (event) => {
+    if (event.kind === "spanStart") {
+      if (event.parentSpanId) {
+        console.log(`  \u2192 ${event.label}...`);
+        return;
+      }
+      const spinner = ora({
+        text: event.label,
+        color: flags.color !== false ? "cyan" : false
+      }).start();
+      activeSpans.set(event.spanId, {
+        spinner,
+        startTime: Date.now()
+      });
+    } else if (event.kind === "spanEnd") {
+      const spanState = activeSpans.get(event.spanId);
+      if (spanState) {
+        const elapsed = Date.now() - spanState.startTime;
+        if (event.outcome === "error") {
+          spanState.spinner.fail(`${spanState.spinner.text} (failed)`);
+        } else if (event.outcome === "skipped") {
+          spanState.spinner.info(`${spanState.spinner.text} (skipped)`);
+        } else {
+          spanState.spinner.succeed(`${spanState.spinner.text} (${elapsed}ms)`);
+        }
+        activeSpans.delete(event.spanId);
+      }
+    }
+  };
+}
+
+// src/commands/db-init.ts
+function mapDbInitFailure(failure) {
+  if (failure.code === "PLANNING_FAILED") {
+    return errorMigrationPlanningFailed({ conflicts: failure.conflicts ?? [] });
+  }
+  if (failure.code === "MARKER_ORIGIN_MISMATCH") {
+    const mismatchParts = [];
+    if (failure.marker?.coreHash !== failure.destination?.coreHash && failure.marker?.coreHash && failure.destination?.coreHash) {
+      mismatchParts.push(
+        `coreHash (marker: ${failure.marker.coreHash}, destination: ${failure.destination.coreHash})`
+      );
+    }
+    if (failure.marker?.profileHash !== failure.destination?.profileHash && failure.marker?.profileHash && failure.destination?.profileHash) {
+      mismatchParts.push(
+        `profileHash (marker: ${failure.marker.profileHash}, destination: ${failure.destination.profileHash})`
+      );
+    }
+    return errorRuntime(
+      `Existing contract marker does not match plan destination.${mismatchParts.length > 0 ? ` 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",
+          ...failure.marker?.coreHash ? { markerCoreHash: failure.marker.coreHash } : {},
+          ...failure.destination?.coreHash ? { destinationCoreHash: failure.destination.coreHash } : {},
+          ...failure.marker?.profileHash ? { markerProfileHash: failure.marker.profileHash } : {},
+          ...failure.destination?.profileHash ? { destinationProfileHash: failure.destination.profileHash } : {}
+        }
+      }
+    );
+  }
+  if (failure.code === "RUNNER_FAILED") {
+    return errorRuntime(failure.summary, {
+      why: failure.why ?? "Migration runner failed",
+      fix: "Fix the schema mismatch (db init is additive-only), or drop/reset the database and re-run `prisma-next db init`",
+      meta: {
+        code: "RUNNER_FAILED",
+        ...failure.meta ?? {}
+      }
+    });
+  }
+  const exhaustive = failure.code;
+  throw new Error(`Unhandled DbInitFailure code: ${exhaustive}`);
+}
+async function executeDbInitCommand(options, flags, startTime) {
+  const config = await loadConfig(options.config);
+  const configPath = options.config ? relative(process.cwd(), resolve(options.config)) : "prisma-next.config.ts";
+  const contractPathAbsolute = config.contract?.output ? resolve(config.contract.output) : resolve("src/prisma/contract.json");
+  const contractPath = relative(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") {
+      return notOk(
+        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}`
+        })
+      );
+    }
+    return notOk(
+      errorUnexpected(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) {
+    return notOk(
+      errorContractValidationFailed(
+        `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,
+        { where: { path: contractPathAbsolute } }
+      )
+    );
+  }
+  const dbConnection = options.db ?? config.db?.connection;
+  if (!dbConnection) {
+    return notOk(
+      errorDatabaseConnectionRequired({
+        why: `Database connection is required for db init (set db.connection in ${configPath}, or pass --db <url>)`
+      })
+    );
+  }
+  if (!config.driver) {
+    return notOk(errorDriverRequired({ why: "Config.driver is required for db init" }));
+  }
+  if (!config.target.migrations) {
+    return notOk(
+      errorTargetMigrationNotSupported({
+        why: `Target "${config.target.id}" does not support migrations`
+      })
+    );
+  }
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    driver: config.driver,
+    extensionPacks: config.extensionPacks ?? []
+  });
+  const onProgress = createProgressAdapter({ flags });
+  try {
+    const result = await client.dbInit({
+      contractIR: contractJson,
+      mode: options.plan ? "plan" : "apply",
+      connection: dbConnection,
+      onProgress
+    });
+    if (!result.ok) {
+      return notOk(mapDbInitFailure(result.failure));
+    }
+    const profileHash = result.value.marker?.profileHash;
+    const dbInitResult = {
+      ok: true,
+      mode: result.value.mode,
+      plan: {
+        targetId: config.target.targetId,
+        destination: {
+          coreHash: result.value.marker?.coreHash ?? "",
+          ...profileHash ? { profileHash } : {}
+        },
+        operations: result.value.plan.operations.map((op) => ({
+          id: op.id,
+          label: op.label,
+          operationClass: op.operationClass
+        }))
+      },
+      ...result.value.execution ? {
+        execution: {
+          operationsPlanned: result.value.execution.operationsPlanned,
+          operationsExecuted: result.value.execution.operationsExecuted
+        }
+      } : {},
+      ...result.value.marker ? {
+        marker: {
+          coreHash: result.value.marker.coreHash,
+          ...result.value.marker.profileHash ? { profileHash: result.value.marker.profileHash } : {}
+        }
+      } : {},
+      summary: result.value.summary,
+      timings: { total: Date.now() - startTime }
+    };
+    return ok(dbInitResult);
+  } catch (error) {
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Unexpected error during db init: ${error instanceof Error ? error.message : String(error)}`
+      })
+    );
+  } finally {
+    await client.close();
+  }
+}
 function createDbInitCommand() {
   const command = new Command("init");
   setCommandDescriptions(
@@ -50,275 +270,18 @@ function createDbInitCommand() {
   }).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({
+    if (flags.json === "ndjson") {
+      const result2 = notOk(
+        errorJsonFormatNotSupported({
           command: "db init",
           format: "ndjson",
           supportedFormats: ["object"]
-        });
-      }
-      const config = await loadConfig(options.config);
-      const configPath = options.config ? relative(process.cwd(), resolve(options.config)) : "prisma-next.config.ts";
-      const contractPathAbsolute = config.contract?.output ? resolve(config.contract.output) : resolve("src/prisma/contract.json");
-      const contractPath = relative(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 errorUnexpected(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 dbConnection = options.db ?? config.db?.connection;
-      if (!dbConnection) {
-        throw errorDatabaseConnectionRequired({
-          why: `Database connection is required for db init (set db.connection 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(dbConnection), {
-          message: "Connecting to database...",
-          flags
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const code = error.code;
-        const redacted = typeof dbConnection === "string" ? redactDatabaseUrl(dbConnection) : void 0;
-        throw errorRuntime("Database connection failed", {
-          why: message,
-          fix: "Verify the database connection, ensure the database is reachable, and confirm credentials/permissions",
-          meta: {
-            ...typeof code !== "undefined" ? { code } : {},
-            ...redacted ?? {}
-          }
-        });
-      }
-      try {
-        const stack = createControlPlaneStack({
-          target: config.target,
-          adapter: config.adapter,
-          driver: driverDescriptor,
-          extensionPacks: config.extensionPacks
-        });
-        const familyInstance = config.family.create(stack);
-        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, stack });
-        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 exitCode2 = handleResult(result2, flags);
+      process.exit(exitCode2);
+    }
+    const result = await executeDbInitCommand(options, flags, startTime);
     const exitCode = handleResult(result, flags, (dbInitResult) => {
       if (flags.json === "object") {
         console.log(formatDbInitJson(dbInitResult));