@prisma-next/cli 0.3.0-pr.99.6 → 0.4.0-dev.1

package/src/control-api/types.ts

@@ -1,15 +1,21 @@
-import type { CoreSchemaView } from '@prisma-next/core-control-plane/schema-view';
+import type {
+  ContractSourceDiagnostics,
+  ContractSourceProvider,
+} from '@prisma-next/config/config-types';
+import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   ControlAdapterDescriptor,
   ControlDriverDescriptor,
   ControlExtensionDescriptor,
   ControlFamilyDescriptor,
   ControlTargetDescriptor,
+  CoreSchemaView,
   MigrationPlannerConflict,
+  MigrationPlanOperation,
   SignDatabaseResult,
   VerifyDatabaseResult,
   VerifyDatabaseSchemaResult,
-} from '@prisma-next/core-control-plane/types';
+} from '@prisma-next/framework-components/control';
 import type { Result } from '@prisma-next/utils/result';
 
 // ============================================================================
@@ -31,7 +37,7 @@ export interface ControlClientOptions {
   // biome-ignore lint/suspicious/noExplicitAny: required for contravariance - SqlFamilyDescriptor.create has specific parameter types
   readonly family: ControlFamilyDescriptor<any, any>;
   // biome-ignore lint/suspicious/noExplicitAny: required for contravariance - SqlControlTargetDescriptor extends with additional methods
-  readonly target: ControlTargetDescriptor<any, any, any, any>;
+  readonly target: ControlTargetDescriptor<any, any, any>;
   // biome-ignore lint/suspicious/noExplicitAny: required for contravariance in adapter.create()
   readonly adapter: ControlAdapterDescriptor<any, any, any>;
   /** Optional - control client can be created without driver for offline operations */
@@ -56,6 +62,8 @@ export interface ControlClientOptions {
  */
 export type ControlActionName =
   | 'dbInit'
+  | 'dbUpdate'
+  | 'migrationApply'
   | 'verify'
   | 'schemaVerify'
   | 'sign'
@@ -105,8 +113,8 @@ export type OnControlProgress = (event: ControlProgressEvent) => void;
  * Options for the verify operation.
  */
 export interface VerifyOptions {
-  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
-  readonly contractIR: unknown;
+  /** Contract or unvalidated JSON - validated at runtime via familyInstance.validateContract() */
+  readonly contract: unknown;
   /**
    * Database connection. If provided, verify will connect before executing.
    * If omitted, the client must already be connected.
@@ -121,8 +129,8 @@ export interface VerifyOptions {
  * Options for the schemaVerify operation.
  */
 export interface SchemaVerifyOptions {
-  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
-  readonly contractIR: unknown;
+  /** Contract or unvalidated JSON - validated at runtime via familyInstance.validateContract() */
+  readonly contract: unknown;
   /**
    * Whether to use strict mode for schema verification.
    * In strict mode, extra tables/columns are reported as issues.
@@ -143,8 +151,8 @@ export interface SchemaVerifyOptions {
  * Options for the sign operation.
  */
 export interface SignOptions {
-  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
-  readonly contractIR: unknown;
+  /** Contract or unvalidated JSON - validated at runtime via familyInstance.validateContract() */
+  readonly contract: unknown;
   /**
    * Path to the contract file (for metadata in the result).
    */
@@ -167,8 +175,8 @@ export interface SignOptions {
  * Options for the dbInit operation.
  */
 export interface DbInitOptions {
-  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
-  readonly contractIR: unknown;
+  /** Contract or unvalidated JSON - validated at runtime via familyInstance.validateContract() */
+  readonly contract: unknown;
   /**
    * Mode for the dbInit operation.
    * - 'plan': Returns planned operations without applying
@@ -185,6 +193,36 @@ export interface DbInitOptions {
   readonly onProgress?: OnControlProgress;
 }
 
+/**
+ * Options for the dbUpdate operation.
+ */
+export interface DbUpdateOptions {
+  /** Contract or unvalidated JSON - validated at runtime via familyInstance.validateContract() */
+  readonly contract: unknown;
+  /**
+   * Mode for the dbUpdate operation.
+   * - 'plan': Returns planned operations without applying
+   * - 'apply': Applies operations and writes marker/ledger
+   */
+  readonly mode: 'plan' | 'apply';
+  /**
+   * Database connection. If provided, dbUpdate will connect before executing.
+   * If omitted, the client must already be connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+  /**
+   * When true, allows applying plans that contain destructive operations
+   * (e.g., DROP TABLE, DROP COLUMN, ALTER TYPE).
+   * When false (default), the operation returns a failure if the plan
+   * includes destructive operations, prompting the user to confirm interactively
+   * or re-run with -y/--yes.
+   */
+  readonly acceptDataLoss?: boolean;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+
 /**
  * Options for the introspect operation.
  */
@@ -203,47 +241,19 @@ export interface IntrospectOptions {
   readonly onProgress?: OnControlProgress;
 }
 
-/**
- * Contract source as a raw value (any JSON-serializable value).
- */
-export interface ContractSourceValue {
-  readonly kind: 'value';
-  readonly value: unknown;
-}
-
-/**
- * Contract source as a lazy loader function.
- */
-export interface ContractSourceLoader {
-  readonly kind: 'loader';
-  readonly load: () => unknown | Promise<unknown>;
-}
-
-/**
- * Discriminated union for contract source.
- * Use `kind` to determine how to resolve the contract.
- */
-export type EmitContractSource = ContractSourceValue | ContractSourceLoader;
-
 /**
  * Contract configuration for emit operation.
  */
 export interface EmitContractConfig {
   /**
-   * Contract source - either a raw value or a loader function.
-   * Switch on `source.kind` to determine how to resolve.
+   * Contract source provider.
    */
-  readonly source: EmitContractSource;
+  readonly sourceProvider: ContractSourceProvider;
   /**
    * Output path for contract.json.
-   * Should be an absolute or relative path.
+   * The .d.ts types file will be colocated (e.g., contract.json → contract.d.ts).
    */
   readonly output: string;
-  /**
-   * Output path for contract.d.ts.
-   * Should be an absolute or relative path.
-   */
-  readonly types: string;
 }
 
 /**
@@ -273,13 +283,18 @@ export interface DbInitSuccess {
       readonly label: string;
       readonly operationClass: string;
     }>;
+    readonly sql?: ReadonlyArray<string>;
+  };
+  readonly destination: {
+    readonly storageHash: string;
+    readonly profileHash?: string;
   };
   readonly execution?: {
     readonly operationsPlanned: number;
     readonly operationsExecuted: number;
   };
   readonly marker?: {
-    readonly coreHash: string;
+    readonly storageHash: string;
     readonly profileHash?: string;
   };
   readonly summary: string;
@@ -300,11 +315,11 @@ export interface DbInitFailure {
   readonly conflicts: ReadonlyArray<MigrationPlannerConflict> | undefined;
   readonly meta: Record<string, unknown> | undefined;
   readonly marker?: {
-    readonly coreHash?: string;
+    readonly storageHash?: string;
     readonly profileHash?: string;
   };
   readonly destination?: {
-    readonly coreHash: string;
+    readonly storageHash: string;
     readonly profileHash?: string | undefined;
   };
 }
@@ -315,13 +330,65 @@ export interface DbInitFailure {
  */
 export type DbInitResult = Result<DbInitSuccess, DbInitFailure>;
 
+/**
+ * Successful dbUpdate result.
+ */
+export interface DbUpdateSuccess {
+  readonly mode: 'plan' | 'apply';
+  readonly plan: {
+    readonly operations: ReadonlyArray<{
+      readonly id: string;
+      readonly label: string;
+      readonly operationClass: string;
+    }>;
+    readonly sql?: ReadonlyArray<string>;
+  };
+  readonly destination: {
+    readonly storageHash: string;
+    readonly profileHash?: string;
+  };
+  readonly execution?: {
+    readonly operationsPlanned: number;
+    readonly operationsExecuted: number;
+  };
+  readonly marker?: {
+    readonly storageHash: string;
+    readonly profileHash?: string;
+  };
+  readonly summary: string;
+}
+
+/**
+ * Failure codes for dbUpdate operation.
+ */
+export type DbUpdateFailureCode = 'PLANNING_FAILED' | 'RUNNER_FAILED' | 'DESTRUCTIVE_CHANGES';
+
+/**
+ * Failure details for dbUpdate operation.
+ */
+export interface DbUpdateFailure {
+  readonly code: DbUpdateFailureCode;
+  readonly summary: string;
+  readonly why: string | undefined;
+  readonly conflicts: ReadonlyArray<MigrationPlannerConflict> | undefined;
+  readonly meta: Record<string, unknown> | undefined;
+}
+
+/**
+ * Result type for dbUpdate operation.
+ * Uses Result pattern: success returns DbUpdateSuccess, failure returns DbUpdateFailure.
+ */
+export type DbUpdateResult = Result<DbUpdateSuccess, DbUpdateFailure>;
+
 /**
  * Successful emit result.
  * Contains the hashes and paths of emitted files.
  */
 export interface EmitSuccess {
-  /** Core hash of the emitted contract */
-  readonly coreHash: string;
+  /** Storage hash of the emitted contract */
+  readonly storageHash: string;
+  /** Execution hash of the emitted contract (if execution section exists) */
+  readonly executionHash?: string;
   /** Profile hash of the emitted contract (target-specific) */
   readonly profileHash: string;
   /** The emitted contract as JSON string */
@@ -333,7 +400,10 @@ export interface EmitSuccess {
 /**
  * Failure codes for emit operation.
  */
-export type EmitFailureCode = 'CONTRACT_SOURCE_INVALID' | 'EMIT_FAILED';
+export type EmitFailureCode =
+  | 'CONTRACT_SOURCE_INVALID'
+  | 'CONTRACT_VALIDATION_FAILED'
+  | 'EMIT_FAILED';
 
 /**
  * Failure details for emit operation.
@@ -343,6 +413,7 @@ export interface EmitFailure {
   readonly summary: string;
   readonly why: string | undefined;
   readonly meta: Record<string, unknown> | undefined;
+  readonly diagnostics?: ContractSourceDiagnostics;
 }
 
 /**
@@ -351,6 +422,125 @@ export interface EmitFailure {
  */
 export type EmitResult = Result<EmitSuccess, EmitFailure>;
 
+// ============================================================================
+// Migration Apply Types
+// ============================================================================
+
+/**
+ * A pre-planned migration step ready for execution.
+ * Contains the manifest metadata and the serialized operations from ops.json.
+ */
+export interface MigrationApplyStep {
+  readonly dirName: string;
+  readonly from: string;
+  readonly to: string;
+  readonly toContract: Contract;
+  readonly operations: readonly MigrationPlanOperation[];
+}
+
+/**
+ * Options for the migrationApply operation.
+ */
+export interface MigrationApplyOptions {
+  /**
+   * Hash of the database state this apply path starts from.
+   * This is resolved by the caller (typically the CLI orchestration layer).
+   */
+  readonly originHash: string;
+  /**
+   * Hash of the target contract this apply path must reach.
+   * This is resolved by the caller (typically the CLI orchestration layer).
+   */
+  readonly destinationHash: string;
+  /**
+   * Ordered list of migrations to execute from originHash to destinationHash.
+   * The execution layer does not choose defaults; it only executes this explicit path.
+   */
+  readonly pendingMigrations: readonly MigrationApplyStep[];
+  /**
+   * Database connection. If provided, migrationApply will connect before executing.
+   * If omitted, the client must already be connected.
+   */
+  readonly connection?: unknown;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+
+/**
+ * Record of a successfully applied migration.
+ */
+export interface MigrationApplyAppliedEntry {
+  readonly dirName: string;
+  readonly from: string;
+  readonly to: string;
+  readonly operationsExecuted: number;
+}
+
+/**
+ * Successful migrationApply result.
+ */
+export interface MigrationApplySuccess {
+  readonly migrationsApplied: number;
+  readonly markerHash: string;
+  readonly applied: readonly MigrationApplyAppliedEntry[];
+  readonly summary: string;
+}
+
+/**
+ * Failure codes for migrationApply operation.
+ */
+export type MigrationApplyFailureCode = 'RUNNER_FAILED' | 'MIGRATION_PATH_NOT_FOUND';
+
+/**
+ * Failure details for migrationApply operation.
+ */
+export interface MigrationApplyFailure {
+  readonly code: MigrationApplyFailureCode;
+  readonly summary: string;
+  readonly why: string | undefined;
+  readonly meta: Record<string, unknown> | undefined;
+}
+
+/**
+ * Result type for migrationApply operation.
+ */
+export type MigrationApplyResult = Result<MigrationApplySuccess, MigrationApplyFailure>;
+
+// ============================================================================
+// Standalone Contract Emit Types
+// ============================================================================
+
+/**
+ * Options for the standalone executeContractEmit function.
+ * Used by tooling (e.g., Vite plugin) that needs to emit contracts
+ * without the full ControlClient infrastructure.
+ */
+export interface ContractEmitOptions {
+  /** Path to the prisma-next.config.ts file */
+  readonly configPath: string;
+  /** Optional AbortSignal for cancellation support */
+  readonly signal?: AbortSignal;
+}
+
+/**
+ * Result from the standalone executeContractEmit function.
+ */
+export interface ContractEmitResult {
+  /** Hash of the storage contract (schema-level) */
+  readonly storageHash: string;
+  /** Hash of the execution contract (if execution section exists) */
+  readonly executionHash?: string;
+  /** Hash of the profile (target+extensions) */
+  readonly profileHash: string;
+  /** Paths to the emitted files */
+  readonly files: {
+    /** Path to the emitted contract.json file */
+    readonly json: string;
+    /** Path to the emitted contract.d.ts file */
+    readonly dts: string;
+  };
+}
+
 // ============================================================================
 // Client Interface
 // ============================================================================
@@ -397,7 +587,7 @@ export interface ControlClient {
 
   /**
    * Verifies database marker matches the contract.
-   * Compares coreHash and profileHash.
+   * Compares storageHash and profileHash.
    *
    * @returns Structured result (ok: false for mismatch, not throwing)
    * @throws If not connected or infrastructure failure
@@ -414,9 +604,9 @@ export interface ControlClient {
   schemaVerify(options: SchemaVerifyOptions): Promise<VerifyDatabaseSchemaResult>;
 
   /**
-   * Signs the database with a contract marker.
-   * Writes or updates the contract marker if schema verification passes.
-   * Idempotent (no-op if marker already matches).
+   * Signs the database with a contract signature.
+   * Writes or updates the signature if schema verification passes.
+   * Idempotent (no-op if signature already matches).
    *
    * @returns Structured result
    * @throws If not connected or infrastructure failure
@@ -433,6 +623,38 @@ export interface ControlClient {
    */
   dbInit(options: DbInitOptions): Promise<DbInitResult>;
 
+  /**
+   * Updates a database schema to match the current contract.
+   * Creates the signature table if it does not exist. No preconditions required.
+   * Allows additive, widening, and destructive operation classes.
+   *
+   * @param options.mode - 'plan' to preview, 'apply' to execute
+   * @returns Result pattern: Ok with planned/executed operations, NotOk with failure details
+   * @throws If not connected, target doesn't support migrations, or infrastructure failure
+   */
+  dbUpdate(options: DbUpdateOptions): Promise<DbUpdateResult>;
+
+  /**
+   * Reads the contract marker from the database.
+   * Returns null if no marker exists (fresh database).
+   *
+   * @throws If not connected or infrastructure failure
+   */
+  readMarker(): Promise<ContractMarkerRecord | null>;
+
+  /**
+   * Applies pre-planned on-disk migrations to the database.
+   * Each migration runs in its own transaction with full execution checks.
+   * Resume-safe: re-running after failure picks up from the last applied migration.
+   *
+   * @param options.originHash - Explicit source hash for the apply path
+   * @param options.destinationHash - Explicit destination hash for the apply path
+   * @param options.pendingMigrations - Ordered migrations to execute
+   * @returns Result pattern: Ok with applied details, NotOk with failure details
+   * @throws If not connected, target doesn't support migrations, or infrastructure failure
+   */
+  migrationApply(options: MigrationApplyOptions): Promise<MigrationApplyResult>;
+
   /**
    * Introspects the database schema.
    *

package/src/exports/config-types.ts

@@ -1,6 +1,7 @@
-// Re-export core-control-plane config types for convenience
+// Re-export config package types for convenience
 export type {
   ContractConfig,
+  ContractSourceContext,
   PrismaNextConfig,
-} from '@prisma-next/core-control-plane/config-types';
-export { defineConfig } from '@prisma-next/core-control-plane/config-types';
+} from '@prisma-next/config/config-types';
+export { defineConfig } from '@prisma-next/config/config-types';

package/src/exports/control-api.ts

@@ -10,18 +10,24 @@
 
 // Re-export core control plane types for consumer convenience
 export type {
-  ControlPlaneStack,
+  ControlStack,
   SignDatabaseResult,
   VerifyDatabaseResult,
   VerifyDatabaseSchemaResult,
-} from '@prisma-next/core-control-plane/types';
+} from '@prisma-next/framework-components/control';
 // Client factory
 export { createControlClient } from '../control-api/client';
 
+// Contract enrichment (merges framework-derived capabilities and extension pack metadata)
+export { enrichContract } from '../control-api/contract-enrichment';
+
+// Standalone operations (for tooling that doesn't need full client)
+export { executeContractEmit } from '../control-api/operations/contract-emit';
+
 // CLI-specific types
 export type {
-  ContractSourceLoader,
-  ContractSourceValue,
+  ContractEmitOptions,
+  ContractEmitResult,
   ControlActionName,
   ControlClient,
   ControlClientOptions,
@@ -31,8 +37,12 @@ export type {
   DbInitOptions,
   DbInitResult,
   DbInitSuccess,
+  DbUpdateFailure,
+  DbUpdateFailureCode,
+  DbUpdateOptions,
+  DbUpdateResult,
+  DbUpdateSuccess,
   EmitContractConfig,
-  EmitContractSource,
   EmitFailure,
   EmitFailureCode,
   EmitOptions,

package/src/load-ts-contract.ts

@@ -1,15 +1,16 @@
 import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { ContractIR } from '@prisma-next/contract/ir';
+import { pathToFileURL } from 'node:url';
+import type { Contract } from '@prisma-next/contract/types';
 import type { Plugin } from 'esbuild';
 import { build } from 'esbuild';
+import { join } from 'pathe';
 
 export interface LoadTsContractOptions {
   readonly allowlist?: ReadonlyArray<string>;
 }
 
-const DEFAULT_ALLOWLIST = ['@prisma-next/*'];
+const DEFAULT_ALLOWLIST = ['@prisma-next/*', 'node:crypto'];
 
 function isAllowedImport(importPath: string, allowlist: ReadonlyArray<string>): boolean {
   for (const pattern of allowlist) {
@@ -18,6 +19,11 @@ function isAllowedImport(importPath: string, allowlist: ReadonlyArray<string>):
       if (importPath === prefix || importPath.startsWith(`${prefix}/`)) {
         return true;
       }
+    } else if (pattern.endsWith('*')) {
+      const prefix = pattern.slice(0, -1);
+      if (importPath.startsWith(prefix)) {
+        return true;
+      }
     } else if (importPath === pattern) {
       return true;
     }
@@ -30,26 +36,31 @@ function validatePurity(value: unknown): void {
     return;
   }
 
-  const seen = new WeakSet();
+  const path = new WeakSet();
+
   function check(value: unknown): void {
     if (value === null || typeof value !== 'object') {
       return;
     }
 
-    if (seen.has(value)) {
+    if (path.has(value)) {
       throw new Error('Contract export contains circular references');
     }
-    seen.add(value);
+    path.add(value);
 
-    for (const key in value) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (descriptor && (descriptor.get || descriptor.set)) {
-        throw new Error(`Contract export contains getter/setter at key "${key}"`);
-      }
-      if (descriptor && typeof descriptor.value === 'function') {
-        throw new Error(`Contract export contains function at key "${key}"`);
+    try {
+      for (const key in value) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor && (descriptor.get || descriptor.set)) {
+          throw new Error(`Contract export contains getter/setter at key "${key}"`);
+        }
+        if (descriptor && typeof descriptor.value === 'function') {
+          throw new Error(`Contract export contains function at key "${key}"`);
+        }
+        check((value as Record<string, unknown>)[key]);
       }
-      check((value as Record<string, unknown>)[key]);
+    } finally {
+      path.delete(value);
     }
   }
 
@@ -92,7 +103,7 @@ function createImportAllowlistPlugin(allowlist: ReadonlyArray<string>, entryPath
 }
 
 /**
- * Loads a contract from a TypeScript file and returns it as ContractIR.
+ * Loads a contract from a TypeScript file and returns it as Contract.
  *
  * **Responsibility: Parsing Only**
  * This function loads and parses a TypeScript contract file. It does NOT normalize the contract.
@@ -103,13 +114,13 @@ function createImportAllowlistPlugin(allowlist: ReadonlyArray<string>, entryPath
  *
  * @param entryPath - Path to the TypeScript contract file
  * @param options - Optional configuration (import allowlist)
- * @returns The contract as ContractIR (should already be normalized)
+ * @returns The contract as Contract (should already be normalized)
  * @throws Error if the contract cannot be loaded or is not JSON-serializable
  */
 export async function loadContractFromTs(
   entryPath: string,
   options?: LoadTsContractOptions,
-): Promise<ContractIR> {
+): Promise<Contract> {
   const allowlist = options?.allowlist ?? DEFAULT_ALLOWLIST;
 
   if (!existsSync(entryPath)) {
@@ -175,7 +186,7 @@ export async function loadContractFromTs(
     }
     writeFileSync(tempFile, bundleContent, 'utf-8');
 
-    const module = (await import(`file://${tempFile}`)) as {
+    const module = (await import(/* @vite-ignore */ pathToFileURL(tempFile).href)) as {
       default?: unknown;
       contract?: unknown;
     };
@@ -199,7 +210,7 @@ export async function loadContractFromTs(
 
     validatePurity(contract);
 
-    return contract as ContractIR;
+    return contract as Contract;
   } catch (error) {
     try {
       if (tempFile) {

package/src/utils/cli-errors.ts

@@ -1,8 +1,8 @@
 /**
- * Re-export all domain error factories from core-control-plane for convenience.
+ * Re-export all domain error factories from @prisma-next/errors for convenience.
  * CLI-specific errors (e.g., Commander.js argument validation) can be added here if needed.
  */
-export type { CliErrorConflict, CliErrorEnvelope } from '@prisma-next/core-control-plane/errors';
+export type { CliErrorConflict, CliErrorEnvelope } from '@prisma-next/errors/control';
 export {
   CliStructuredError,
   errorConfigFileNotFound,
@@ -14,13 +14,19 @@ export {
   errorDriverRequired,
   errorFamilyReadMarkerSqlRequired,
   errorFileNotFound,
-  errorHashMismatch,
-  errorJsonFormatNotSupported,
-  errorMarkerMissing,
   errorMigrationPlanningFailed,
   errorQueryRunnerFactoryRequired,
-  errorRuntime,
   errorTargetMigrationNotSupported,
-  errorTargetMismatch,
   errorUnexpected,
-} from '@prisma-next/core-control-plane/errors';
+} from '@prisma-next/errors/control';
+export {
+  ERROR_CODE_DESTRUCTIVE_CHANGES,
+  errorDestructiveChanges,
+  errorHashMismatch,
+  errorMarkerMissing,
+  errorMarkerRequired,
+  errorRunnerFailed,
+  errorRuntime,
+  errorSchemaVerificationFailed,
+  errorTargetMismatch,
+} from '@prisma-next/errors/execution';