@prisma-next/cli 0.5.0-dev.7 → 0.5.0-dev.71

package/src/control-api/operations/db-init.ts

@@ -2,20 +2,30 @@ import type { Contract } from '@prisma-next/contract/types';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   ControlDriverInstance,
+  ControlExtensionDescriptor,
   ControlFamilyInstance,
-  MigrationPlan,
-  MigrationPlannerResult,
-  MigrationRunnerResult,
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { notOk, ok } from '@prisma-next/utils/result';
-import type { DbInitResult, DbInitSuccess, OnControlProgress } from '../types';
-import { extractOperationStatements } from './extract-operation-statements';
-import { createOperationCallbacks, stripOperations } from './migration-helpers';
+import type { DbInitResult, OnControlProgress } from '../types';
+import { executeAggregateApply } from './db-apply-aggregate';
 
 /**
- * Options for executing dbInit operation.
+ * Options for executing the `db init` operation.
+ *
+ * `db init` runs the loader → planner → runner pipeline:
+ *
+ * 1. {@link executeAggregateApply} loads a `ContractSpaceAggregate` via
+ *    {@link import('@prisma-next/migration-tools/aggregate').loadContractSpaceAggregate}
+ *    from the supplied descriptor set + on-disk on-disk artefacts.
+ * 2. The aggregate planner runs with `callerPolicy.ignoreGraphFor`
+ *    locked to the app member — synth strategy for the app, graph-walk
+ *    for every extension.
+ * 3. The runner's `executeAcrossSpaces` applies the per-space plans
+ *    inside one outer transaction.
+ *
+ * `extensionPacks` mirrors `Config.extensionPacks` (descriptor list).
+ * The loader (sub-spec § Loader) is the sole descriptor-import boundary.
  */
 export interface ExecuteDbInitOptions<TFamilyId extends string, TTargetId extends string> {
   readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
@@ -28,261 +38,49 @@ export interface ExecuteDbInitOptions<TFamilyId extends string, TTargetId extend
     ControlFamilyInstance<TFamilyId, unknown>
   >;
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;
+  /**
+   * On-disk migrations directory the aggregate loader reads on-disk
+   * artefacts from. Required.
+   */
+  readonly migrationsDir: string;
+  /**
+   * Resolved adapter target id. Threaded through to the loader for
+   * target-consistency checks across descriptors and the app contract.
+   */
+  readonly targetId: TTargetId;
+  /**
+   * Declared extension descriptors. Defaults to an empty list, which
+   * routes through the same loader → planner → runner pipeline with no
+   * extension members in the aggregate.
+   */
+  readonly extensionPacks?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
   /** Optional progress callback for observing operation progress */
   readonly onProgress?: OnControlProgress;
 }
 
 /**
- * Executes the dbInit operation.
+ * Execute `db init` against the configured contract.
  *
- * This is the core logic extracted from the CLI command, without any file I/O,
- * process.exit(), or console output. It uses the Result pattern to return
- * success or failure details.
- *
- * @param options - The options for executing dbInit
- * @returns Result with DbInitSuccess on success, DbInitFailure on failure
+ * Routes through the loader → planner → runner pipeline (sub-spec
+ * "Commit-by-commit § Commit 4"). Always additive-only; destructive
+ * changes belong to `db update`.
  */
 export async function executeDbInit<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbInitOptions<TFamilyId, TTargetId>,
 ): Promise<DbInitResult> {
-  const { driver, familyInstance, contract, mode, migrations, frameworkComponents, onProgress } =
-    options;
-
-  // Create planner and runner from target migrations capability
-  const planner = migrations.createPlanner(familyInstance);
-  const runner = migrations.createRunner(familyInstance);
-
-  // Introspect live schema
-  const introspectSpanId = 'introspect';
-  onProgress?.({
-    action: 'dbInit',
-    kind: 'spanStart',
-    spanId: introspectSpanId,
-    label: 'Introspecting database schema',
-  });
-  const schemaIR = await familyInstance.introspect({ driver });
-  onProgress?.({
-    action: 'dbInit',
-    kind: 'spanEnd',
-    spanId: introspectSpanId,
-    outcome: 'ok',
-  });
-
-  // Policy for init mode (additive only)
-  const policy = { allowedOperationClasses: ['additive'] as const };
-
-  // Plan migration
-  const planSpanId = 'plan';
-  onProgress?.({
-    action: 'dbInit',
-    kind: 'spanStart',
-    spanId: planSpanId,
-    label: 'Planning migration',
-  });
-  const plannerResult: MigrationPlannerResult = await planner.plan({
-    contract,
-    schema: schemaIR,
-    policy,
-    // `db init` does not produce a `migration.ts`, so the from-hash on the
-    // resulting plan is never surfaced to authoring — pass empty string.
-    fromHash: '',
-    frameworkComponents,
-  });
-
-  if (plannerResult.kind === 'failure') {
-    onProgress?.({
-      action: 'dbInit',
-      kind: 'spanEnd',
-      spanId: planSpanId,
-      outcome: 'error',
-    });
-    return notOk({
-      code: 'PLANNING_FAILED' as const,
-      summary: 'Migration planning failed due to conflicts',
-      conflicts: plannerResult.conflicts,
-      why: undefined,
-      meta: undefined,
-    });
-  }
-
-  const migrationPlan: MigrationPlan = plannerResult.plan;
-  onProgress?.({
-    action: 'dbInit',
-    kind: 'spanEnd',
-    spanId: planSpanId,
-    outcome: 'ok',
-  });
-
-  // Check for existing marker - handle idempotency and mismatch errors
-  const checkMarkerSpanId = 'checkMarker';
-  onProgress?.({
-    action: 'dbInit',
-    kind: 'spanStart',
-    spanId: checkMarkerSpanId,
-    label: 'Checking database signature',
-  });
-  const existingMarker = await familyInstance.readMarker({ driver });
-  if (existingMarker) {
-    const markerMatchesDestination =
-      existingMarker.storageHash === migrationPlan.destination.storageHash &&
-      (!migrationPlan.destination.profileHash ||
-        existingMarker.profileHash === migrationPlan.destination.profileHash);
-
-    if (markerMatchesDestination) {
-      // Already at destination - return success with no operations
-      onProgress?.({
-        action: 'dbInit',
-        kind: 'spanEnd',
-        spanId: checkMarkerSpanId,
-        outcome: 'skipped',
-      });
-      const result: DbInitSuccess = {
-        mode,
-        plan: { operations: [] },
-        destination: {
-          storageHash: migrationPlan.destination.storageHash,
-          ...ifDefined('profileHash', migrationPlan.destination.profileHash),
-        },
-        ...ifDefined(
-          'execution',
-          mode === 'apply' ? { operationsPlanned: 0, operationsExecuted: 0 } : undefined,
-        ),
-        ...ifDefined(
-          'marker',
-          mode === 'apply'
-            ? {
-                storageHash: existingMarker.storageHash,
-                profileHash: existingMarker.profileHash,
-              }
-            : undefined,
-        ),
-        summary: 'Database already at target contract state',
-      };
-      return ok(result);
-    }
-
-    // Marker exists but doesn't match destination - fail
-    onProgress?.({
-      action: 'dbInit',
-      kind: 'spanEnd',
-      spanId: checkMarkerSpanId,
-      outcome: 'error',
-    });
-    return notOk({
-      code: 'MARKER_ORIGIN_MISMATCH' as const,
-      summary: 'Existing contract marker does not match plan destination',
-      marker: {
-        storageHash: existingMarker.storageHash,
-        profileHash: existingMarker.profileHash,
-      },
-      destination: {
-        storageHash: migrationPlan.destination.storageHash,
-        profileHash: migrationPlan.destination.profileHash,
-      },
-      why: undefined,
-      conflicts: undefined,
-      meta: undefined,
-    });
-  }
-
-  onProgress?.({
-    action: 'dbInit',
-    kind: 'spanEnd',
-    spanId: checkMarkerSpanId,
-    outcome: 'ok',
-  });
-
-  // Plan mode - don't execute
-  if (mode === 'plan') {
-    const planSql = extractOperationStatements(familyInstance.familyId, migrationPlan.operations);
-    const result: DbInitSuccess = {
-      mode: 'plan',
-      plan: {
-        operations: stripOperations(migrationPlan.operations),
-        ...ifDefined('sql', planSql),
-      },
-      destination: {
-        storageHash: migrationPlan.destination.storageHash,
-        ...ifDefined('profileHash', migrationPlan.destination.profileHash),
-      },
-      summary: `Planned ${migrationPlan.operations.length} operation(s)`,
-    };
-    return ok(result);
-  }
-
-  // Apply mode - execute runner
-  const applySpanId = 'apply';
-  onProgress?.({
+  const result = await executeAggregateApply<TFamilyId, TTargetId>({
+    driver: options.driver,
+    familyInstance: options.familyInstance,
+    contract: options.contract,
+    mode: options.mode,
+    migrations: options.migrations,
+    frameworkComponents: options.frameworkComponents,
+    migrationsDir: options.migrationsDir,
+    targetId: options.targetId,
+    extensionPacks: options.extensionPacks ?? [],
+    policy: { allowedOperationClasses: ['additive'] },
     action: 'dbInit',
-    kind: 'spanStart',
-    spanId: applySpanId,
-    label: 'Applying migration plan',
+    ...ifDefined('onProgress', options.onProgress),
   });
-
-  const callbacks = createOperationCallbacks(onProgress, 'dbInit', applySpanId);
-
-  const runnerResult: MigrationRunnerResult = await runner.execute({
-    plan: migrationPlan,
-    driver,
-    destinationContract: contract,
-    policy,
-    ...ifDefined('callbacks', 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) {
-    onProgress?.({
-      action: 'dbInit',
-      kind: 'spanEnd',
-      spanId: applySpanId,
-      outcome: 'error',
-    });
-    return notOk({
-      code: 'RUNNER_FAILED' as const,
-      summary: runnerResult.failure.summary,
-      why: runnerResult.failure.why,
-      meta: runnerResult.failure.meta,
-      conflicts: undefined,
-    });
-  }
-
-  const execution = runnerResult.value;
-
-  onProgress?.({
-    action: 'dbInit',
-    kind: 'spanEnd',
-    spanId: applySpanId,
-    outcome: 'ok',
-  });
-
-  const result: DbInitSuccess = {
-    mode: 'apply',
-    plan: {
-      operations: stripOperations(migrationPlan.operations),
-    },
-    destination: {
-      storageHash: migrationPlan.destination.storageHash,
-      ...ifDefined('profileHash', migrationPlan.destination.profileHash),
-    },
-    execution: {
-      operationsPlanned: execution.operationsPlanned,
-      operationsExecuted: execution.operationsExecuted,
-    },
-    marker: migrationPlan.destination.profileHash
-      ? {
-          storageHash: migrationPlan.destination.storageHash,
-          profileHash: migrationPlan.destination.profileHash,
-        }
-      : { storageHash: migrationPlan.destination.storageHash },
-    summary: `Applied ${execution.operationsExecuted} operation(s), database signed`,
-  };
-  return ok(result);
+  return result as DbInitResult;
 }

package/src/control-api/operations/db-update.ts

@@ -2,25 +2,27 @@ import type { Contract } from '@prisma-next/contract/types';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   ControlDriverInstance,
+  ControlExtensionDescriptor,
   ControlFamilyInstance,
-  MigrationPlannerResult,
-  MigrationRunnerResult,
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { notOk, ok } from '@prisma-next/utils/result';
-import type { DbUpdateResult, DbUpdateSuccess, OnControlProgress } from '../types';
-import { extractOperationStatements } from './extract-operation-statements';
-import { createOperationCallbacks, stripOperations } from './migration-helpers';
+import { notOk } from '@prisma-next/utils/result';
+import type { DbUpdateResult, OnControlProgress } from '../types';
+import { executeAggregateApply } from './db-apply-aggregate';
 
-// F12: db update allows additive, widening, and destructive operations.
 const DB_UPDATE_POLICY = {
   allowedOperationClasses: ['additive', 'widening', 'destructive'] as const,
 } as const;
 
 /**
- * Options for the executeDbUpdate operation.
- * Config-agnostic: receives pre-resolved driver, family, contract, and migrations capability.
+ * Options for the `db update` operation.
+ *
+ * Same loader → planner → runner pipeline as `db init`, but with the
+ * widened operation policy (additive + widening + destructive). The
+ * destructive-change confirmation gate runs at this layer: when
+ * `mode === 'apply'` and `acceptDataLoss` is `false`, the operation
+ * pre-plans, surfaces destructive ops to the caller, and aborts.
  */
 export interface ExecuteDbUpdateOptions<TFamilyId extends string, TTargetId extends string> {
   readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
@@ -34,190 +36,71 @@ export interface ExecuteDbUpdateOptions<TFamilyId extends string, TTargetId exte
   >;
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;
   readonly acceptDataLoss?: boolean;
-  /** Optional progress callback for observing operation progress. */
+  readonly migrationsDir: string;
+  readonly targetId: TTargetId;
+  readonly extensionPacks?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
   readonly onProgress?: OnControlProgress;
 }
 
 /**
- * Executes the db update operation: introspect → plan → (optionally) apply → marker.
+ * Execute `db update` against the configured contract.
  *
- * db update is a pure reconciliation command: it introspects the live schema, plans the diff
- * to the destination contract, and applies operations. The marker is bookkeeping only — written
- * after apply so that `verify` and `db init` can reference it, but never read or validated
- * by db update itself. The runner creates the marker table if it does not exist.
+ * Routes through the loader → planner → runner pipeline. Destructive
+ * operations require either `acceptDataLoss: true` or a prior
+ * `mode: 'plan'` invocation that surfaces the destructive ops; the
+ * confirmation gate is implemented here so the lower-level applier
+ * remains policy-agnostic.
  */
 export async function executeDbUpdate<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbUpdateOptions<TFamilyId, TTargetId>,
 ): Promise<DbUpdateResult> {
-  const { driver, familyInstance, contract, mode, migrations, frameworkComponents, onProgress } =
-    options;
-
-  const planner = migrations.createPlanner(familyInstance);
-  const runner = migrations.createRunner(familyInstance);
-
-  const introspectSpanId = 'introspect';
-  onProgress?.({
-    action: 'dbUpdate',
-    kind: 'spanStart',
-    spanId: introspectSpanId,
-    label: 'Introspecting database schema',
-  });
-  const schemaIR = await familyInstance.introspect({ driver });
-  onProgress?.({
-    action: 'dbUpdate',
-    kind: 'spanEnd',
-    spanId: introspectSpanId,
-    outcome: 'ok',
-  });
-
-  const policy = DB_UPDATE_POLICY;
-
-  const planSpanId = 'plan';
-  onProgress?.({
-    action: 'dbUpdate',
-    kind: 'spanStart',
-    spanId: planSpanId,
-    label: 'Planning migration',
-  });
-  const plannerResult: MigrationPlannerResult = await planner.plan({
-    contract,
-    schema: schemaIR,
-    policy,
-    // `db update` does not produce a `migration.ts`, so the from-hash on the
-    // resulting plan is never surfaced to authoring — pass empty string.
-    fromHash: '',
-    frameworkComponents,
-  });
-  if (plannerResult.kind === 'failure') {
-    onProgress?.({
-      action: 'dbUpdate',
-      kind: 'spanEnd',
-      spanId: planSpanId,
-      outcome: 'error',
-    });
-    return notOk({
-      code: 'PLANNING_FAILED',
-      summary: 'Migration planning failed due to conflicts',
-      conflicts: plannerResult.conflicts,
-      why: undefined,
-      meta: undefined,
-    });
-  }
-  onProgress?.({
-    action: 'dbUpdate',
-    kind: 'spanEnd',
-    spanId: planSpanId,
-    outcome: 'ok',
-  });
-
-  const migrationPlan = plannerResult.plan;
-
-  if (mode === 'plan') {
-    const planSql = extractOperationStatements(familyInstance.familyId, migrationPlan.operations);
-    const result: DbUpdateSuccess = {
-      mode: 'plan',
-      plan: {
-        operations: stripOperations(migrationPlan.operations),
-        ...(planSql !== undefined ? { sql: planSql } : {}),
-      },
-      destination: {
-        storageHash: migrationPlan.destination.storageHash,
-        ...ifDefined('profileHash', migrationPlan.destination.profileHash),
-      },
-      summary: `Planned ${migrationPlan.operations.length} operation(s)`,
-    };
-    return ok(result);
-  }
-
-  // When applying, require explicit acceptance for destructive operations
-  if (!options.acceptDataLoss) {
-    const destructiveOps = migrationPlan.operations
-      .filter((op) => op.operationClass === 'destructive')
-      .map((op) => ({ id: op.id, label: op.label }));
-    if (destructiveOps.length > 0) {
-      return notOk({
-        code: 'DESTRUCTIVE_CHANGES',
-        summary: `Planned ${destructiveOps.length} destructive operation(s) that require confirmation`,
-        why: 'Destructive operations require confirmation — re-run with -y to accept',
-        conflicts: undefined,
-        meta: { destructiveOperations: destructiveOps },
-      });
-    }
-  }
-
-  const applySpanId = 'apply';
-  onProgress?.({
-    action: 'dbUpdate',
-    kind: 'spanStart',
-    spanId: applySpanId,
-    label: 'Applying migration plan',
-  });
-
-  const callbacks = createOperationCallbacks(onProgress, 'dbUpdate', applySpanId);
-
-  const runnerResult: MigrationRunnerResult = await runner.execute({
-    plan: migrationPlan,
-    driver,
-    destinationContract: contract,
-    policy,
-    ...(callbacks ? { callbacks } : {}),
-    // db update plans and applies from a single introspection pass, so per-operation pre/postchecks
-    // and idempotency probes are intentionally disabled to avoid redundant roundtrips.
-    executionChecks: {
-      prechecks: false,
-      postchecks: false,
-      idempotencyChecks: false,
-    },
-    frameworkComponents,
-  });
-
-  if (!runnerResult.ok) {
-    onProgress?.({
-      action: 'dbUpdate',
-      kind: 'spanEnd',
-      spanId: applySpanId,
-      outcome: 'error',
-    });
-    return notOk({
-      code: 'RUNNER_FAILED',
-      summary: runnerResult.failure.summary,
-      why: runnerResult.failure.why,
-      meta: runnerResult.failure.meta,
-      conflicts: undefined,
-    });
+  const sharedInputs = {
+    driver: options.driver,
+    familyInstance: options.familyInstance,
+    contract: options.contract,
+    migrations: options.migrations,
+    frameworkComponents: options.frameworkComponents,
+    migrationsDir: options.migrationsDir,
+    targetId: options.targetId,
+    extensionPacks: options.extensionPacks ?? [],
+    policy: DB_UPDATE_POLICY,
+    action: 'dbUpdate' as const,
+    ...ifDefined('onProgress', options.onProgress),
+  };
+  if (options.mode === 'apply' && !options.acceptDataLoss) {
+    const gate = await guardDestructiveChanges<TFamilyId, TTargetId>(sharedInputs);
+    if (gate !== null) return gate;
   }
+  return (await executeAggregateApply<TFamilyId, TTargetId>({
+    ...sharedInputs,
+    mode: options.mode,
+  })) as DbUpdateResult;
+}
 
-  const execution = runnerResult.value;
-  onProgress?.({
-    action: 'dbUpdate',
-    kind: 'spanEnd',
-    spanId: applySpanId,
-    outcome: 'ok',
+/**
+ * Pre-plan once when running `db update apply` without `acceptDataLoss`.
+ * Surfaces destructive operations across every space; if any are
+ * planned, returns a `DESTRUCTIVE_CHANGES` failure that the CLI shows
+ * as a confirmation prompt. Returns `null` when the apply is safe to
+ * run.
+ */
+async function guardDestructiveChanges<TFamilyId extends string, TTargetId extends string>(
+  sharedInputs: Omit<Parameters<typeof executeAggregateApply<TFamilyId, TTargetId>>[0], 'mode'>,
+): Promise<DbUpdateResult | null> {
+  const planResult = (await executeAggregateApply<TFamilyId, TTargetId>({
+    ...sharedInputs,
+    mode: 'plan',
+  })) as DbUpdateResult;
+  if (!planResult.ok) return planResult;
+  const destructiveOps = planResult.value.plan.operations
+    .filter((op) => op.operationClass === 'destructive')
+    .map((op) => ({ id: op.id, label: op.label }));
+  if (destructiveOps.length === 0) return null;
+  return notOk({
+    code: 'DESTRUCTIVE_CHANGES',
+    summary: `Planned ${destructiveOps.length} destructive operation(s) that require confirmation`,
+    why: 'Destructive operations require confirmation — re-run with -y to accept',
+    conflicts: undefined,
+    meta: { destructiveOperations: destructiveOps },
   });
-
-  const result: DbUpdateSuccess = {
-    mode: 'apply',
-    plan: {
-      operations: stripOperations(migrationPlan.operations),
-    },
-    destination: {
-      storageHash: migrationPlan.destination.storageHash,
-      ...ifDefined('profileHash', migrationPlan.destination.profileHash),
-    },
-    execution: {
-      operationsPlanned: execution.operationsPlanned,
-      operationsExecuted: execution.operationsExecuted,
-    },
-    marker: migrationPlan.destination.profileHash
-      ? {
-          storageHash: migrationPlan.destination.storageHash,
-          profileHash: migrationPlan.destination.profileHash,
-        }
-      : { storageHash: migrationPlan.destination.storageHash },
-    summary:
-      execution.operationsExecuted === 0
-        ? 'Database already matches contract, signature updated'
-        : `Applied ${execution.operationsExecuted} operation(s), signature updated`,
-  };
-  return ok(result);
 }