@prisma-next/cli 0.3.0-dev.5 → 0.3.0-dev.53

package/src/commands/db-init.ts

@@ -1,18 +1,15 @@
 import { readFile } from 'node:fs/promises';
 import { relative, resolve } from 'node:path';
-import type {
-  MigrationPlan,
-  MigrationPlannerResult,
-  MigrationPlanOperation,
-  MigrationRunnerResult,
-} from '@prisma-next/core-control-plane/types';
-import { redactDatabaseUrl } from '@prisma-next/utils/redact-db-url';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { loadConfig } from '../config-loader';
-import { performAction } from '../utils/action';
+import { createControlClient } from '../control-api/client';
+import type { DbInitFailure } from '../control-api/types';
 import {
+  CliStructuredError,
   errorContractValidationFailed,
-  errorDatabaseUrlRequired,
+  errorDatabaseConnectionRequired,
   errorDriverRequired,
   errorFileNotFound,
   errorJsonFormatNotSupported,
@@ -22,11 +19,7 @@ import {
   errorUnexpected,
 } from '../utils/cli-errors';
 import { setCommandDescriptions } from '../utils/command-helpers';
-import {
-  assertContractRequirementsSatisfied,
-  assertFrameworkComponentsCompatible,
-} from '../utils/framework-components';
-import { parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
   type DbInitResult,
   formatCommandHelp,
@@ -35,8 +28,8 @@ import {
   formatDbInitPlanOutput,
   formatStyledHeader,
 } from '../utils/output';
+import { createProgressAdapter } from '../utils/progress-adapter';
 import { handleResult } from '../utils/result-handler';
-import { withSpinner } from '../utils/spinner';
 
 interface DbInitOptions {
   readonly db?: string;
@@ -54,6 +47,246 @@ interface DbInitOptions {
   readonly 'no-color'?: boolean;
 }
 
+/**
+ * Maps a DbInitFailure to a CliStructuredError for consistent error handling.
+ */
+function mapDbInitFailure(failure: DbInitFailure): CliStructuredError {
+  if (failure.code === 'PLANNING_FAILED') {
+    return errorMigrationPlanningFailed({ conflicts: failure.conflicts ?? [] });
+  }
+
+  if (failure.code === 'MARKER_ORIGIN_MISMATCH') {
+    const mismatchParts: string[] = [];
+    if (
+      failure.marker?.storageHash !== failure.destination?.storageHash &&
+      failure.marker?.storageHash &&
+      failure.destination?.storageHash
+    ) {
+      mismatchParts.push(
+        `storageHash (marker: ${failure.marker.storageHash}, destination: ${failure.destination.storageHash})`,
+      );
+    }
+    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',
+          ...ifDefined('markerStorageHash', failure.marker?.storageHash),
+          ...ifDefined('destinationStorageHash', failure.destination?.storageHash),
+          ...ifDefined('markerProfileHash', failure.marker?.profileHash),
+          ...ifDefined('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 ?? {}),
+      },
+    });
+  }
+
+  // Exhaustive check - TypeScript will error if a new code is added but not handled
+  const exhaustive: never = failure.code;
+  throw new Error(`Unhandled DbInitFailure code: ${exhaustive}`);
+}
+
+/**
+ * Executes the db init command and returns a structured Result.
+ */
+async function executeDbInitCommand(
+  options: DbInitOptions,
+  flags: GlobalFlags,
+  startTime: number,
+): Promise<Result<DbInitResult, CliStructuredError>> {
+  // Load config
+  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);
+
+  // Output header
+  if (flags.json !== 'object' && !flags.quiet) {
+    const details: Array<{ label: string; value: string }> = [
+      { 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);
+  }
+
+  // Load contract file
+  let contractJsonContent: string;
+  try {
+    contractJsonContent = await readFile(contractPathAbsolute, 'utf-8');
+  } catch (error) {
+    if (error instanceof Error && (error as { code?: string }).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: Record<string, unknown>;
+  try {
+    contractJson = JSON.parse(contractJsonContent) as Record<string, unknown>;
+  } catch (error) {
+    return notOk(
+      errorContractValidationFailed(
+        `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,
+        { where: { path: contractPathAbsolute } },
+      ),
+    );
+  }
+
+  // Resolve database connection (--db flag or config.db.connection)
+  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>)`,
+      }),
+    );
+  }
+
+  // Check for driver
+  if (!config.driver) {
+    return notOk(errorDriverRequired({ why: 'Config.driver is required for db init' }));
+  }
+
+  // Check target supports migrations via the migrations capability
+  if (!config.target.migrations) {
+    return notOk(
+      errorTargetMigrationNotSupported({
+        why: `Target "${config.target.id}" does not support migrations`,
+      }),
+    );
+  }
+
+  // Create control client
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    driver: config.driver,
+    extensionPacks: config.extensionPacks ?? [],
+  });
+
+  // Create progress adapter
+  const onProgress = createProgressAdapter({ flags });
+
+  try {
+    // Call dbInit with connection and progress callback
+    // Connection happens inside dbInit with a 'connect' progress span
+    const result = await client.dbInit({
+      contractIR: contractJson,
+      mode: options.plan ? 'plan' : 'apply',
+      connection: dbConnection,
+      onProgress,
+    });
+
+    // Handle failures by mapping to CLI structured error
+    if (!result.ok) {
+      return notOk(mapDbInitFailure(result.failure));
+    }
+
+    // Convert success result to CLI output format
+    const profileHash = result.value.marker?.profileHash;
+    const dbInitResult: DbInitResult = {
+      ok: true,
+      mode: result.value.mode,
+      plan: {
+        targetId: config.target.targetId,
+        destination: {
+          storageHash: result.value.marker?.storageHash ?? '',
+          ...ifDefined('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: {
+              storageHash: result.value.marker.storageHash,
+              ...ifDefined('profileHash', result.value.marker.profileHash),
+            },
+          }
+        : {}),
+      summary: result.value.summary,
+      timings: { total: Date.now() - startTime },
+    };
+
+    return ok(dbInitResult);
+  } catch (error) {
+    // Driver already throws CliStructuredError for connection failures
+    // Use static type guard to work across module boundaries
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+
+    // Wrap unexpected errors
+    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();
+  }
+}
+
 export function createDbInitCommand(): Command {
   const command = new Command('init');
   setCommandDescriptions(
@@ -86,355 +319,21 @@ export function createDbInitCommand(): Command {
       const flags = parseGlobalFlags(options);
       const startTime = Date.now();
 
-      const result = await performAction(async () => {
-        if (flags.json === 'ndjson') {
-          throw errorJsonFormatNotSupported({
+      // Validate JSON format option
+      if (flags.json === 'ndjson') {
+        const result = notOk(
+          errorJsonFormatNotSupported({
             command: 'db init',
             format: 'ndjson',
             supportedFormats: ['object'],
-          });
-        }
+          }),
+        );
+        const exitCode = handleResult(result, flags);
+        process.exit(exitCode);
+      }
 
-        // Load config
-        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);
-
-        // Output header
-        if (flags.json !== 'object' && !flags.quiet) {
-          const details: Array<{ label: string; value: string }> = [
-            { 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);
-        }
-
-        // Load contract file
-        let contractJsonContent: string;
-        try {
-          contractJsonContent = await readFile(contractPathAbsolute, 'utf-8');
-        } catch (error) {
-          if (error instanceof Error && (error as { code?: string }).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: Record<string, unknown>;
-        try {
-          contractJson = JSON.parse(contractJsonContent) as Record<string, unknown>;
-        } catch (error) {
-          throw errorContractValidationFailed(
-            `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,
-            { where: { path: contractPathAbsolute } },
-          );
-        }
-
-        // Resolve database URL
-        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>)`,
-          });
-        }
-
-        // Check for driver
-        if (!config.driver) {
-          throw errorDriverRequired({ why: 'Config.driver is required for db init' });
-        }
-        const driverDescriptor = config.driver;
-
-        // Check target supports migrations via the migrations capability
-        if (!config.target.migrations) {
-          throw errorTargetMigrationNotSupported({
-            why: `Target "${config.target.id}" does not support migrations`,
-          });
-        }
-        const migrations = config.target.migrations;
-
-        // Create driver
-        let driver: Awaited<ReturnType<(typeof driverDescriptor)['create']>>;
-        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 as { code?: unknown }).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 {
-          // Create family instance
-          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,
-          );
-
-          // Validate contract
-          const contractIR = familyInstance.validateContractIR(contractJson);
-          assertContractRequirementsSatisfied({
-            contract: contractIR,
-            family: config.family,
-            target: config.target,
-            adapter: config.adapter,
-            extensionPacks: config.extensionPacks,
-          });
-
-          // Create planner and runner from target migrations capability
-          const planner = migrations.createPlanner(familyInstance);
-          const runner = migrations.createRunner(familyInstance);
-
-          // Introspect live schema
-          const schemaIR = await withSpinner(() => familyInstance.introspect({ driver }), {
-            message: 'Introspecting database schema...',
-            flags,
-          });
-
-          // Policy for init mode (additive only)
-          const policy = { allowedOperationClasses: ['additive'] as const };
-
-          // Plan migration
-          const plannerResult: MigrationPlannerResult = 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: MigrationPlan = plannerResult.plan;
-
-          // Check for existing marker - handle idempotency and mismatch errors
-          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) {
-              // Already at destination - return success with no operations
-              const dbInitResult: DbInitResult = {
-                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 dbInitResult;
-            }
-
-            // Marker exists but doesn't match destination - fail
-            const coreHashMismatch = existingMarker.coreHash !== migrationPlan.destination.coreHash;
-            const profileHashMismatch =
-              migrationPlan.destination.profileHash &&
-              existingMarker.profileHash !== migrationPlan.destination.profileHash;
-
-            const mismatchParts: string[] = [];
-            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 }
-                    : {}),
-                },
-              },
-            );
-          }
-
-          // Plan mode - don't execute
-          if (options.plan) {
-            const dbInitResult: DbInitResult = {
-              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 dbInitResult;
-          }
-
-          // Apply mode - execute runner
-          // Log main message once, then show individual operations via callbacks
-          if (!flags.quiet && flags.json !== 'object') {
-            console.log('Applying migration plan and verifying schema...');
-          }
-
-          const callbacks = {
-            onOperationStart: (op: MigrationPlanOperation) => {
-              if (!flags.quiet && flags.json !== 'object') {
-                console.log(`  → ${op.label}...`);
-              }
-            },
-            onOperationComplete: (_op: MigrationPlanOperation) => {
-              // Could log completion if needed
-            },
-          };
-
-          const runnerResult: MigrationRunnerResult = 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: Record<string, unknown> = {
-              code: runnerResult.failure.code,
-              ...(runnerResult.failure.meta ?? {}),
-            };
-            const sqlState = typeof meta['sqlState'] === 'string' ? meta['sqlState'] : undefined;
-            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`'
-                  : undefined;
-
-            throw errorRuntime(runnerResult.failure.summary, {
-              why:
-                runnerResult.failure.why ?? `Migration runner failed: ${runnerResult.failure.code}`,
-              ...(fix ? { fix } : {}),
-              meta,
-            });
-          }
-
-          const execution = runnerResult.value;
-
-          const dbInitResult: 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 result = await executeDbInitCommand(options, flags, startTime);
 
-      // Handle result
       const exitCode = handleResult(result, flags, (dbInitResult) => {
         if (flags.json === 'object') {
           console.log(formatDbInitJson(dbInitResult));