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

package/src/commands/db-verify.ts

@@ -27,10 +27,12 @@ import {
   errorTargetMismatch,
   errorUnexpected,
 } from '../utils/cli-errors';
+import { combineSchemaResults } from '../utils/combine-schema-results';
 import {
   addGlobalOptions,
   maskConnectionUrl,
   resolveContractPath,
+  resolveMigrationPaths,
   setCommandDescriptions,
   setCommandExamples,
 } from '../utils/command-helpers';
@@ -346,22 +348,42 @@ async function executeDbVerifyCommand(
   const setupResult = await resolveVerifySetup(paths, options, mode);
   if (!setupResult.ok) return setupResult;
   const { contractJson, dbConnection, contractPathAbsolute } = setupResult.value;
+  const { migrationsDir } = resolveMigrationPaths(options.config, setupResult.value.config);
 
   const client = createVerifyClient(setupResult.value);
   const onProgress = createProgressAdapter({ ui, flags });
 
   try {
+    // Single-contract marker verification preserved for the existing
+    // marker / target / hash failure surface (`PN-RUN-3001/3002/3003`).
+    // The aggregate verifier (run below for the per-space marker /
+    // schema checks) does not duplicate this: it concerns itself with
+    // marker-vs-on-disk and orphan-marker drift, not the
+    // hash-mismatch-against-the-app-contract lane that today's
+    // `client.verify` covers.
     const verifyResult = await client.verify({
       contract: contractJson,
       connection: dbConnection,
       onProgress,
     });
 
-    // If verification failed, map to CLI structured error
     if (!verifyResult.ok) {
       return notOk(mapVerifyFailure(verifyResult));
     }
 
+    // Aggregate verifier (loader → verifier pipeline). Runs the layout
+    // precheck, marker-aware per-space verifier, and (full mode only)
+    // per-space pre-projected schema verification (closes F23).
+    const aggregateResult = await client.dbVerify({
+      contract: contractJson,
+      migrationsDir,
+      strict: options.strict ?? false,
+      skipSchema: mode === 'marker-only',
+      skipMarker: false,
+      onProgress,
+    });
+    if (!aggregateResult.ok) return notOk(aggregateResult.failure);
+
     if (mode === 'marker-only') {
       return ok({
         ok: true,
@@ -381,14 +403,13 @@ async function executeDbVerifyCommand(
       });
     }
 
-    const schemaVerifyResult = await client.schemaVerify({
-      contract: contractJson,
-      strict: options.strict ?? false,
-      onProgress,
-    });
-
-    if (!schemaVerifyResult.ok) {
-      return notOk(schemaVerifyResult);
+    const combined = combineSchemaResults(
+      aggregateResult.value.schemaResults,
+      aggregateResult.value.appSpaceId,
+      options.strict ?? false,
+    );
+    if (!combined.ok) {
+      return notOk(combined);
     }
 
     return ok({
@@ -401,9 +422,9 @@ async function executeDbVerifyCommand(
       ...ifDefined('missingCodecs', verifyResult.missingCodecs),
       ...ifDefined('codecCoverageSkipped', verifyResult.codecCoverageSkipped),
       schema: {
-        summary: schemaVerifyResult.summary,
-        counts: schemaVerifyResult.schema.counts,
-        strict: schemaVerifyResult.meta?.strict ?? false,
+        summary: combined.summary,
+        counts: combined.schema.counts,
+        strict: combined.meta?.strict ?? false,
       },
       meta: {
         ...(verifyResult.meta ?? {}),
@@ -429,19 +450,30 @@ async function executeDbSchemaOnlyVerifyCommand(
   const setupResult = await resolveVerifySetup(paths, options, 'schema-only');
   if (!setupResult.ok) return setupResult;
   const { contractJson, dbConnection, contractPathAbsolute } = setupResult.value;
+  const { migrationsDir } = resolveMigrationPaths(options.config, setupResult.value.config);
 
   const client = createVerifyClient(setupResult.value);
   const onProgress = createProgressAdapter({ ui, flags });
 
   try {
-    const schemaVerifyResult = await client.schemaVerify({
+    await client.connect(dbConnection);
+    const aggregateResult = await client.dbVerify({
       contract: contractJson,
+      migrationsDir,
       strict: options.strict ?? false,
-      connection: dbConnection,
+      skipSchema: false,
+      skipMarker: true,
       onProgress,
     });
+    if (!aggregateResult.ok) return notOk(aggregateResult.failure);
 
-    return ok(schemaVerifyResult);
+    return ok(
+      combineSchemaResults(
+        aggregateResult.value.schemaResults,
+        aggregateResult.value.appSpaceId,
+        options.strict ?? false,
+      ),
+    );
   } catch (error) {
     return wrapVerifyError(error, contractPathAbsolute, 'db verify --schema-only');
   } finally {

package/src/commands/init/index.ts

@@ -113,7 +113,7 @@ export function createInitCommand(): Command {
  *   we honour it (e.g. testing flows where stdin is stubbed).
  *
  * Exported so callers and tests can derive the same value without
- * touching `process` globals — F14 of the M1/M2 review.
+ * touching `process` globals.
  */
 export function deriveCanPrompt(opts: {
   readonly flagsInteractive: boolean | undefined;

package/src/commands/init/init.ts

@@ -569,7 +569,7 @@ async function runInstall(ctx: {
   /**
    * FR2.1 — set when the user already declares `@types/node` directly in
    * `dependencies` or `devDependencies`. We then skip adding it so a
-   * pinned major (e.g. `^18` for a Node 18 runtime) survives `init`
+   * locked major (e.g. `^18` for a Node 18 runtime) survives `init`
    * unchanged. Transitive presence is intentionally ignored: detecting
    * it requires lockfile introspection and the realistic clobber risk
    * is the direct-pin case.
@@ -585,7 +585,7 @@ async function runInstall(ctx: {
   // Pin it as a devDep rather than relying on a transitive resolution
   // through `dotenv` (whose types bundle is internal and not guaranteed
   // across versions). Skip when the user already declares `@types/node`
-  // directly so a pinned major (e.g. `^18` for a Node 18 runtime) is
+  // directly so a locked major (e.g. `^18` for a Node 18 runtime) is
   // preserved. Listed last so the install log still leads with the
   // user-relevant `prisma-next` line.
   const devDeps = hasTypesNode ? ['prisma-next'] : ['prisma-next', '@types/node'];

package/src/commands/migration-apply.ts

@@ -110,7 +110,7 @@ async function executeMigrationApplyCommand(
   startTime: number,
 ): Promise<Result<MigrationApplyResult, CliStructuredErrorType>> {
   const config = await loadConfig(options.config);
-  const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(
+  const { configPath, appMigrationsDir, appMigrationsRelative, refsDir } = resolveMigrationPaths(
     options.config,
     config,
   );
@@ -173,7 +173,7 @@ async function executeMigrationApplyCommand(
   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 (typeof dbConnection === 'string') {
       details.push({
@@ -197,7 +197,7 @@ async function executeMigrationApplyCommand(
   // Read migrations and build migration chain model (offline — no DB needed)
   let migrations: Awaited<ReturnType<typeof loadMigrationPackages>>;
   try {
-    migrations = await loadMigrationPackages(migrationsDir);
+    migrations = await loadMigrationPackages(appMigrationsDir);
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(mapMigrationToolsError(error));
@@ -248,9 +248,9 @@ async function executeMigrationApplyCommand(
       if (marker?.storageHash) {
         return notOk(
           errorRuntime('Database has state but no migrations exist', {
-            why: `The database marker hash "${marker.storageHash}" exists but no migrations were found in ${migrationsRelative}`,
+            why: `The database marker hash "${marker.storageHash}" exists but no migrations were found in ${appMigrationsRelative}`,
             fix: 'Ensure the migrations directory is correct. If the database was managed with `db init` or `db update`, run `prisma-next db sign` to update the marker.',
-            meta: { markerHash: marker.storageHash, migrationsDir: migrationsRelative },
+            meta: { markerHash: marker.storageHash, migrationsDir: appMigrationsRelative },
           }),
         );
       }
@@ -258,9 +258,9 @@ async function executeMigrationApplyCommand(
       if (destinationHash !== EMPTY_CONTRACT_HASH) {
         return notOk(
           errorRuntime('Current contract has no planned migrations', {
-            why: `No migrations were found in ${migrationsRelative}, but current contract hash is "${destinationHash}"`,
+            why: `No migrations were found in ${appMigrationsRelative}, but current contract hash is "${destinationHash}"`,
             fix: 'Run `prisma-next migration plan` to create a migration for the current contract.',
-            meta: { destinationHash, migrationsDir: migrationsRelative },
+            meta: { destinationHash, migrationsDir: appMigrationsRelative },
           }),
         );
       }
@@ -295,7 +295,7 @@ async function executeMigrationApplyCommand(
     if (markerHash !== undefined && !migrations.graph.nodes.has(markerHash)) {
       return notOk(
         errorRuntime('Database marker does not match any known migration', {
-          why: `The database marker hash "${markerHash}" is not found in the migration history at ${migrationsRelative}`,
+          why: `The database marker hash "${markerHash}" is not found in the migration history at ${appMigrationsRelative}`,
           fix: 'Ensure the migrations directory matches this database. If the database was managed with `db init` or `db update`, run `prisma-next db sign` to update the marker.',
           meta: { markerHash, knownNodes: [...migrations.graph.nodes] },
         }),
@@ -305,7 +305,7 @@ async function executeMigrationApplyCommand(
     if (!migrations.graph.nodes.has(destinationHash)) {
       return notOk(
         errorRuntime('Current contract has no planned migration path', {
-          why: `Current contract hash "${destinationHash}" is not present in the migration history at ${migrationsRelative}`,
+          why: `Current contract hash "${destinationHash}" is not present in the migration history at ${appMigrationsRelative}`,
           fix: 'Run `prisma-next migration plan` to create a migration for the current contract, then re-run apply.',
           meta: { destinationHash, knownNodes: [...migrations.graph.nodes] },
         }),

package/src/commands/migration-new.ts

@@ -70,7 +70,7 @@ async function executeMigrationNewCommand(
   options: MigrationNewOptions,
 ): Promise<Result<MigrationNewResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { migrationsDir, migrationsRelative } = resolveMigrationPaths(options.config, config);
+  const { appMigrationsDir, appMigrationsRelative } = resolveMigrationPaths(options.config, config);
 
   const contractPathAbsolute = resolveContractPath(config);
 
@@ -120,7 +120,7 @@ async function executeMigrationNewCommand(
   let fromContractSourceDir: string | null = null;
 
   try {
-    const packages = await readMigrationsDir(migrationsDir);
+    const packages = await readMigrationsDir(appMigrationsDir);
 
     if (packages.length > 0) {
       const graph = reconstructGraph(packages);
@@ -130,7 +130,7 @@ async function executeMigrationNewCommand(
         if (!match) {
           return notOk(
             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.',
             }),
           );
@@ -171,7 +171,7 @@ async function executeMigrationNewCommand(
   const timestamp = new Date();
   const slug = options.name ?? 'migration';
   const dirName = formatMigrationDirName(timestamp, slug);
-  const packageDir = join(migrationsDir, dirName);
+  const packageDir = join(appMigrationsDir, dirName);
 
   // `migration new` scaffolds an empty `migration.ts` for the user to
   // fill, so we attest over `ops: []`. Re-running self-emit after the

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);