@prisma-next/cli 0.5.0-dev.67 → 0.5.0-dev.68

package/src/commands/migration-plan.ts

@@ -43,6 +43,15 @@ import {
   setCommandDescriptions,
   setCommandExamples,
 } from '../utils/command-helpers';
+import {
+  type ExtensionMigrationsExtensionInput,
+  runContractSpaceExtensionMigrationsPass,
+} from '../utils/contract-space-extension-migrations-pass';
+import {
+  formatContractSpaceDriftWarning,
+  type MigrateExtensionInput,
+  runContractSpaceMigratePass,
+} from '../utils/contract-space-migrate-pass';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import { assertFrameworkComponentsCompatible } from '../utils/framework-components';
 import type { CommonCommandOptions } from '../utils/global-flags';
@@ -92,10 +101,8 @@ async function executeMigrationPlanCommand(
   startTime: number,
 ): Promise<Result<MigrationPlanResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { configPath, migrationsDir, migrationsRelative } = resolveMigrationPaths(
-    options.config,
-    config,
-  );
+  const { configPath, migrationsDir, appMigrationsDir, appMigrationsRelative } =
+    resolveMigrationPaths(options.config, config);
 
   const contractPathAbsolute = resolveContractPath(config);
   const contractPath = relative(process.cwd(), contractPathAbsolute);
@@ -104,7 +111,7 @@ async function executeMigrationPlanCommand(
     const details: Array<{ label: string; value: string }> = [
       { label: 'config', value: configPath },
       { label: 'contract', value: contractPath },
-      { label: 'migrations', value: migrationsRelative },
+      { label: 'migrations', value: appMigrationsRelative },
     ];
     if (options.from) {
       details.push({ label: 'from', value: options.from });
@@ -170,7 +177,7 @@ async function executeMigrationPlanCommand(
   let fromContractSourceDir: string | null = null;
 
   try {
-    const { bundles, graph } = await loadMigrationPackages(migrationsDir);
+    const { bundles, graph } = await loadMigrationPackages(appMigrationsDir);
 
     if (options.from) {
       const resolved = resolveBundleByPrefix(bundles, options.from);
@@ -179,11 +186,11 @@ async function executeMigrationPlanCommand(
         return notOk(
           f.reason === 'ambiguous'
             ? errorRuntime('Multiple matching migrations found', {
-                why: `Prefix "${options.from}" matches ${f.count} migrations in ${migrationsRelative}`,
+                why: `Prefix "${options.from}" matches ${f.count} migrations in ${appMigrationsRelative}`,
                 fix: 'Provide a longer prefix to disambiguate, or omit --from to use the latest migration target.',
               })
             : errorRuntime('Starting contract not found', {
-                why: `No migration with to hash matching "${options.from}" exists in ${migrationsRelative}`,
+                why: `No migration with to hash matching "${options.from}" exists in ${appMigrationsRelative}`,
                 fix: 'Check that the --from hash matches a known migration target hash, or omit --from to use the latest migration target.',
               }),
         );
@@ -220,6 +227,56 @@ async function executeMigrationPlanCommand(
     );
   }
 
+  // Per-space migrate pass: drift detection + on-disk artefact emission for
+  // every loaded extension that exposes a `contractSpace`. Runs *before*
+  // the app-space no-op check so that an extension bump alone (with no
+  // structural app-space change) still re-pins extension artefacts on
+  // disk. Drift warnings are non-fatal — the on-disk artefacts are refreshed
+  // and the user is notified that the bump is being captured.
+  const extensionInputs: readonly MigrateExtensionInput[] = (config.extensionPacks ?? []).map(
+    (pack) => {
+      const cs = (pack as { readonly contractSpace?: MigrateExtensionInput['contractSpace'] })
+        .contractSpace;
+      return cs !== undefined ? { id: pack.id, contractSpace: cs } : { id: pack.id };
+    },
+  );
+  const migratePass = await runContractSpaceMigratePass({
+    migrationsDir,
+    extensionPacks: extensionInputs,
+  });
+  if (!flags.json && !flags.quiet) {
+    for (const drift of migratePass.drifts) {
+      if (drift.kind === 'drift') {
+        ui.stderr(formatContractSpaceDriftWarning(drift));
+      }
+    }
+  }
+
+  // Materialise descriptor-shipped migration packages onto disk under
+  // `migrations/<spaceId>/<dirName>/` for any package not yet present.
+  // Idempotent (existing dirs are left untouched).
+  // Uses `planAllSpaces` for deterministic ordering + duplicate-spaceId
+  // detection.
+  const extensionMigrationsInputs: readonly ExtensionMigrationsExtensionInput[] = (
+    config.extensionPacks ?? []
+  ).map((pack) => {
+    const cs = (
+      pack as {
+        readonly contractSpace?: ExtensionMigrationsExtensionInput['contractSpace'];
+      }
+    ).contractSpace;
+    return cs !== undefined ? { id: pack.id, contractSpace: cs } : { id: pack.id };
+  });
+  const extensionMigrationsResult = await runContractSpaceExtensionMigrationsPass({
+    migrationsDir,
+    extensionPacks: extensionMigrationsInputs,
+  });
+  if (!flags.json && !flags.quiet) {
+    for (const entry of extensionMigrationsResult.emitted) {
+      ui.step(`Emitted ${entry.spaceId}/${entry.dirName}`);
+    }
+  }
+
   // Check for no-op (same hash means no changes)
   if (fromHash === toStorageHash) {
     const result: MigrationPlanResult = {
@@ -253,7 +310,7 @@ async function executeMigrationPlanCommand(
   const timestamp = new Date();
   const slug = options.name ?? 'migration';
   const dirName = formatMigrationDirName(timestamp, slug);
-  const packageDir = join(migrationsDir, dirName);
+  const packageDir = join(appMigrationsDir, dirName);
 
   const baseMetadata: Omit<MigrationMetadata, 'migrationHash' | 'providedInvariants'> = {
     from: fromHash,

package/src/commands/migration-show.ts

@@ -9,6 +9,7 @@ import {
   reconstructGraph,
 } from '@prisma-next/migration-tools/migration-graph';
 import type { OnDiskMigrationPackage } from '@prisma-next/migration-tools/package';
+import { APP_SPACE_ID, spaceMigrationDirectory } from '@prisma-next/migration-tools/spaces';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { relative, resolve } from 'pathe';
@@ -103,16 +104,17 @@ async function executeMigrationShowCommand(
     ? relative(process.cwd(), resolve(options.config))
     : 'prisma-next.config.ts';
 
-  const migrationsDir = resolve(
+  const migrationsDirRoot = resolve(
     options.config ? resolve(options.config, '..') : process.cwd(),
     config.migrations?.dir ?? 'migrations',
   );
-  const migrationsRelative = relative(process.cwd(), migrationsDir);
+  const appMigrationsDir = spaceMigrationDirectory(migrationsDirRoot, APP_SPACE_ID);
+  const appMigrationsRelative = relative(process.cwd(), appMigrationsDir);
 
   if (!flags.json && !flags.quiet) {
     const details: Array<{ label: string; value: string }> = [
       { label: 'config', value: configPath },
-      { label: 'migrations', value: migrationsRelative },
+      { label: 'migrations', value: appMigrationsRelative },
     ];
     if (target) {
       details.push({ label: 'target', value: target });
@@ -132,11 +134,11 @@ async function executeMigrationShowCommand(
     if (target && looksLikePath(target)) {
       pkg = await readMigrationPackage(resolve(target));
     } else {
-      const allPackages = await readMigrationsDir(migrationsDir);
+      const allPackages = await readMigrationsDir(appMigrationsDir);
       if (allPackages.length === 0) {
         return notOk(
           errorRuntime('No migrations found', {
-            why: `No migration packages found in ${migrationsRelative}`,
+            why: `No migration packages found in ${appMigrationsRelative}`,
             fix: 'Run `prisma-next migration plan` to create a migration first.',
           }),
         );

package/src/commands/migration-status.ts

@@ -369,7 +369,7 @@ async function executeMigrationStatusCommand(
   ui: TerminalUI,
 ): Promise<Result<MigrationStatusResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(
+  const { configPath, appMigrationsDir, appMigrationsRelative, refsDir } = resolveMigrationPaths(
     options.config,
     config,
   );
@@ -414,7 +414,7 @@ async function executeMigrationStatusCommand(
   if (!flags.json && !flags.quiet) {
     const details: Array<{ label: string; value: string }> = [
       { label: 'config', value: configPath },
-      { label: 'migrations', value: migrationsRelative },
+      { label: 'migrations', value: appMigrationsRelative },
     ];
     if (dbConnection && hasDriver) {
       details.push({ label: 'database', value: maskConnectionUrl(String(dbConnection)) });
@@ -454,7 +454,7 @@ async function executeMigrationStatusCommand(
   let bundles: readonly OnDiskMigrationPackage[];
   let graph: MigrationGraph;
   try {
-    ({ bundles, graph } = await loadMigrationPackages(migrationsDir));
+    ({ bundles, graph } = await loadMigrationPackages(appMigrationsDir));
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(mapMigrationToolsError(error));

package/src/control-api/client.ts

@@ -28,7 +28,9 @@ import { enrichContract } from './contract-enrichment';
 import { ContractValidationError } from './errors';
 import { executeDbInit } from './operations/db-init';
 import { executeDbUpdate } from './operations/db-update';
+import { type ExecuteDbVerifyResult, executeDbVerify } from './operations/db-verify';
 import { executeMigrationApply } from './operations/migration-apply';
+
 import type {
   ControlActionName,
   ControlClient,
@@ -37,6 +39,7 @@ import type {
   DbInitResult,
   DbUpdateOptions,
   DbUpdateResult,
+  DbVerifyOptions,
   EmitOptions,
   EmitResult,
   IntrospectOptions,
@@ -368,6 +371,9 @@ class ControlClientImpl implements ControlClient {
       mode: options.mode,
       migrations: this.options.target.migrations,
       frameworkComponents,
+      migrationsDir: options.migrationsDir,
+      targetId: this.options.target.targetId,
+      extensionPacks: this.options.extensionPacks ?? [],
       ...ifDefined('onProgress', onProgress),
     });
   }
@@ -396,11 +402,42 @@ class ControlClientImpl implements ControlClient {
       mode: options.mode,
       migrations: this.options.target.migrations,
       frameworkComponents,
+      migrationsDir: options.migrationsDir,
+      targetId: this.options.target.targetId,
+      extensionPacks: this.options.extensionPacks ?? [],
       ...ifDefined('acceptDataLoss', options.acceptDataLoss),
       ...ifDefined('onProgress', onProgress),
     });
   }
 
+  async dbVerify(options: DbVerifyOptions): Promise<ExecuteDbVerifyResult> {
+    const { onProgress } = options;
+    await this.connectWithProgress(options.connection, 'dbVerify', onProgress);
+    const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
+
+    let contract: Contract;
+    try {
+      contract = familyInstance.validateContract(options.contract);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ContractValidationError(message, error);
+    }
+
+    return executeDbVerify({
+      driver,
+      familyInstance,
+      contract,
+      migrationsDir: options.migrationsDir,
+      targetId: this.options.target.targetId,
+      extensionPacks: this.options.extensionPacks ?? [],
+      frameworkComponents,
+      mode: options.strict ? 'strict' : 'lenient',
+      skipSchema: options.skipSchema,
+      skipMarker: options.skipMarker,
+      ...ifDefined('onProgress', onProgress),
+    });
+  }
+
   async readMarker(): Promise<ContractMarkerRecord | null> {
     const { driver, familyInstance } = await this.ensureConnected();
     // The CLI client's readMarker reads the app's marker. Per-extension
@@ -410,6 +447,11 @@ class ControlClientImpl implements ControlClient {
     return familyInstance.readMarker({ driver, space: APP_SPACE_ID });
   }
 
+  async readAllMarkers(): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
+    const { driver, familyInstance } = await this.ensureConnected();
+    return familyInstance.readAllMarkers({ driver });
+  }
+
   async migrationApply(options: MigrationApplyOptions): Promise<MigrationApplyResult> {
     const { onProgress } = options;
     await this.connectWithProgress(options.connection, 'migrationApply', onProgress);