@prisma/migrate 6.6.0-dev.95 → 6.6.0-dev.97

package/dist/migrate/src/SchemaEngine.d.ts

@@ -1,49 +1,27 @@
-import { type MigrateTypes, SchemaContext } from '@prisma/internals';
+import { type MigrateTypes } from '@prisma/internals';
 import type { EngineArgs, EngineResults } from './types';
-export interface SchemaEngineOptions {
-    schemaContext?: SchemaContext;
-    debug?: boolean;
-    enabledPreviewFeatures?: string[];
-}
-export declare class EngineError extends Error {
-    code: number;
-    constructor(message: string, code: number);
-}
-export declare class SchemaEngine {
-    private debug;
-    private child?;
-    private schemaContext?;
-    private listeners;
-    /**  _All_ the logs from the engine process. */
-    private messages;
-    private lastRequest?;
-    /** The fields of the last engine log event with an `ERROR` level. */
-    private lastError;
-    private initPromise?;
-    private enabledPreviewFeatures?;
-    private latestSchema?;
+export interface SchemaEngine {
     isRunning: boolean;
-    constructor({ debug, schemaContext, enabledPreviewFeatures }: SchemaEngineOptions);
     /**
      * Apply the migrations from the migrations directory to the database.
      * This is the command behind prisma migrate deploy.
      */
-    applyMigrations(args: EngineArgs.ApplyMigrationsInput): Promise<EngineResults.ApplyMigrationsOutput>;
+    applyMigrations(input: EngineArgs.ApplyMigrationsInput): Promise<EngineResults.ApplyMigrationsOutput>;
     /**
      * Create the logical database from the Prisma schema.
      */
-    createDatabase(args: EngineArgs.CreateDatabaseInput): Promise<EngineResults.CreateDatabaseOutput>;
+    createDatabase?(input: EngineArgs.CreateDatabaseInput): Promise<EngineResults.CreateDatabaseOutput>;
     /**
      * Create the next migration in the migrations history.
      * If draft is false and there are no unexecutable steps, it will also apply the newly created migration.
      * Note: This will use the shadow database on the connectors where we need one.
      */
-    createMigration(args: EngineArgs.CreateMigrationInput): Promise<EngineResults.CreateMigrationOutput>;
+    createMigration(input: EngineArgs.CreateMigrationInput): Promise<EngineResults.CreateMigrationOutput>;
     /**
      * Execute a database script directly on the specified live database.
      * Note that this may not be defined on all connectors.
      */
-    dbExecute(args: EngineArgs.DbExecuteInput): Promise<EngineResults.DbExecuteOutput>;
+    dbExecute(input: EngineArgs.DbExecuteInput): Promise<EngineResults.DbExecuteOutput>;
     /**
      * Make the Schema engine panic. Only useful to test client error handling.
      */
@@ -55,23 +33,22 @@ export declare class SchemaEngine {
      * Its role is to interpret the diagnostic output,
      * and translate it to a concrete action to be performed by the CLI.
      */
-    devDiagnostic(args: EngineArgs.DevDiagnosticInput): Promise<EngineResults.DevDiagnosticOutput>;
+    devDiagnostic(input: EngineArgs.DevDiagnosticInput): Promise<EngineResults.DevDiagnosticOutput>;
     /**
      * Read the contents of the migrations directory and the migrations table, and returns their relative statuses.
      * At this stage, the Schema engine only reads,
      * it does not write to the database nor the migrations directory, nor does it use a shadow database.
      */
-    diagnoseMigrationHistory(args: EngineArgs.DiagnoseMigrationHistoryInput): Promise<EngineResults.DiagnoseMigrationHistoryOutput>;
+    diagnoseMigrationHistory(input: EngineArgs.DiagnoseMigrationHistoryInput): Promise<EngineResults.DiagnoseMigrationHistoryOutput>;
     /**
      * Make sure the Schema engine can connect to the database from the Prisma schema.
      */
-    ensureConnectionValidity(args: EngineArgs.EnsureConnectionValidityInput): Promise<void>;
+    ensureConnectionValidity(input: EngineArgs.EnsureConnectionValidityInput): Promise<void>;
     /**
      * Development command for migrations.
      * Evaluate the data loss induced by the next migration the engine would generate on the main database.
      */
-    evaluateDataLoss(args: EngineArgs.EvaluateDataLossInput): Promise<EngineResults.EvaluateDataLossOutput>;
-    getDatabaseDescription(schema: string): Promise<string>;
+    evaluateDataLoss(input: EngineArgs.EvaluateDataLossInput): Promise<EngineResults.EvaluateDataLossOutput>;
     /**
      * Get the database version for error reporting.
      * If no argument is given, the version of the database associated to the Prisma schema provided
@@ -82,8 +59,9 @@ export declare class SchemaEngine {
      * Given a Prisma schema, introspect the database definitions and update the schema with the results.
      * `compositeTypeDepth` is optional, and only required for MongoDB.
      */
-    introspect({ schema, force, baseDirectoryPath, viewsDirectoryPath, compositeTypeDepth, // cannot be undefined
-    namespaces, }: EngineArgs.IntrospectParams): Promise<EngineArgs.IntrospectResult>;
+    introspect(input: EngineArgs.IntrospectParams & {
+        viewsDirectoryPath: string;
+    }): Promise<EngineArgs.IntrospectResult>;
     /**
      * Compares two databases schemas from two arbitrary sources,
      * and display the difference as either a human-readable summary,
@@ -93,7 +71,7 @@ export declare class SchemaEngine {
      * The resulting diff should be thought of as a migration from the schema in `args.from` to the schema in `args.to`.
      * By default, we output a human-readable diff. If you want an executable script, pass the "script": true param.
      */
-    migrateDiff(args: EngineArgs.MigrateDiffInput): Promise<EngineResults.MigrateDiffOutput>;
+    migrateDiff(input: EngineArgs.MigrateDiffInput): Promise<EngineResults.MigrateDiffOutput>;
     /**
      * Mark a migration as applied in the migrations table.
      * There are two possible outcomes:
@@ -101,11 +79,11 @@ export declare class SchemaEngine {
      * - The migration is not in the table. We will create a new entry in the migrations table. The started_at and finished_at will be the same.
      * If it is already applied, we return a user-facing error.
      */
-    markMigrationApplied(args: EngineArgs.MarkMigrationAppliedInput): Promise<void>;
+    markMigrationApplied(input: EngineArgs.MarkMigrationAppliedInput): Promise<void>;
     /**
      * Mark an existing failed migration as rolled back in the migrations table. It will still be there, but ignored for all purposes except as audit trail.
      */
-    markMigrationRolledBack(args: EngineArgs.MarkMigrationRolledBackInput): Promise<void>;
+    markMigrationRolledBack(input: EngineArgs.MarkMigrationRolledBackInput): Promise<void>;
     /**
      * Try to make the database empty: no data and no schema.
      * On most connectors, this is implemented by dropping and recreating the database.
@@ -117,19 +95,15 @@ export declare class SchemaEngine {
     /**
      * The command behind db push.
      */
-    schemaPush(args: EngineArgs.SchemaPushInput): Promise<EngineResults.SchemaPush>;
+    schemaPush(input: EngineArgs.SchemaPushInput): Promise<EngineResults.SchemaPush>;
     /**
      * SQL introspection that powers TypedSQL feature
      * @param args
      * @returns
      */
-    introspectSql(args: EngineArgs.IntrospectSqlParams): Promise<EngineResults.IntrospectSqlOutput>;
+    introspectSql(input: EngineArgs.IntrospectSqlParams): Promise<EngineResults.IntrospectSqlOutput>;
+    /**
+     * Stop the engine.
+     */
     stop(): void;
-    private rejectAll;
-    private registerCallback;
-    private handleResponse;
-    private init;
-    private internalInit;
-    private runCommand;
-    private getRPCPayload;
 }

package/dist/migrate/src/SchemaEngineCLI.d.ts

@@ -0,0 +1,139 @@
+import { type MigrateTypes, SchemaContext } from '@prisma/internals';
+import type { SchemaEngine } from './SchemaEngine';
+import type { EngineArgs, EngineResults } from './types';
+export declare class EngineError extends Error {
+    code: number;
+    constructor(message: string, code: number);
+}
+interface SchemaEngineCLISetupInput {
+    debug?: boolean;
+    enabledPreviewFeatures?: string[];
+    schemaContext?: SchemaContext;
+}
+export type SchemaEngineCLIOptions = SchemaEngineCLISetupInput;
+export declare class SchemaEngineCLI implements SchemaEngine {
+    private debug;
+    private child?;
+    private schemaContext?;
+    private listeners;
+    /**  _All_ the logs from the engine process. */
+    private messages;
+    private lastRequest?;
+    /** The fields of the last engine log event with an `ERROR` level. */
+    private lastError;
+    private initPromise?;
+    private enabledPreviewFeatures?;
+    private latestSchema?;
+    isRunning: boolean;
+    private constructor();
+    static setup(input: SchemaEngineCLISetupInput): Promise<SchemaEngineCLI>;
+    /**
+     * Apply the migrations from the migrations directory to the database.
+     * This is the command behind prisma migrate deploy.
+     */
+    applyMigrations(args: EngineArgs.ApplyMigrationsInput): Promise<EngineResults.ApplyMigrationsOutput>;
+    /**
+     * Create the logical database from the Prisma schema.
+     */
+    createDatabase(args: EngineArgs.CreateDatabaseInput): Promise<EngineResults.CreateDatabaseOutput>;
+    /**
+     * Create the next migration in the migrations history.
+     * If draft is false and there are no unexecutable steps, it will also apply the newly created migration.
+     * Note: This will use the shadow database on the connectors where we need one.
+     */
+    createMigration(args: EngineArgs.CreateMigrationInput): Promise<EngineResults.CreateMigrationOutput>;
+    /**
+     * Execute a database script directly on the specified live database.
+     * Note that this may not be defined on all connectors.
+     */
+    dbExecute(args: EngineArgs.DbExecuteInput): Promise<EngineResults.DbExecuteOutput>;
+    /**
+     * Make the Schema engine panic. Only useful to test client error handling.
+     */
+    debugPanic(): Promise<void>;
+    /**
+     * The method called at the beginning of migrate dev to decide the course of action,
+     * based on the current state of the workspace.
+     * It acts as a wrapper around diagnoseMigrationHistory.
+     * Its role is to interpret the diagnostic output,
+     * and translate it to a concrete action to be performed by the CLI.
+     */
+    devDiagnostic(args: EngineArgs.DevDiagnosticInput): Promise<EngineResults.DevDiagnosticOutput>;
+    /**
+     * Read the contents of the migrations directory and the migrations table, and returns their relative statuses.
+     * At this stage, the Schema engine only reads,
+     * it does not write to the database nor the migrations directory, nor does it use a shadow database.
+     */
+    diagnoseMigrationHistory(args: EngineArgs.DiagnoseMigrationHistoryInput): Promise<EngineResults.DiagnoseMigrationHistoryOutput>;
+    /**
+     * Make sure the Schema engine can connect to the database from the Prisma schema.
+     */
+    ensureConnectionValidity(args: EngineArgs.EnsureConnectionValidityInput): Promise<void>;
+    /**
+     * Development command for migrations.
+     * Evaluate the data loss induced by the next migration the engine would generate on the main database.
+     */
+    evaluateDataLoss(args: EngineArgs.EvaluateDataLossInput): Promise<EngineResults.EvaluateDataLossOutput>;
+    getDatabaseDescription(schema: string): Promise<string>;
+    /**
+     * Get the database version for error reporting.
+     * If no argument is given, the version of the database associated to the Prisma schema provided
+     * in the constructor will be returned.
+     */
+    getDatabaseVersion(args?: MigrateTypes.GetDatabaseVersionParams): Promise<string>;
+    /**
+     * Given a Prisma schema, introspect the database definitions and update the schema with the results.
+     * `compositeTypeDepth` is optional, and only required for MongoDB.
+     */
+    introspect({ schema, force, baseDirectoryPath, viewsDirectoryPath, compositeTypeDepth, // cannot be undefined
+    namespaces, }: EngineArgs.IntrospectParams): Promise<EngineArgs.IntrospectResult>;
+    /**
+     * Compares two databases schemas from two arbitrary sources,
+     * and display the difference as either a human-readable summary,
+     * or an executable script that can be passed to dbExecute.
+     * Connection to a shadow database is only necessary when either the from or the to params is a migrations directory.
+     * Diffs have a direction. Which source is from and which is to matters.
+     * The resulting diff should be thought of as a migration from the schema in `args.from` to the schema in `args.to`.
+     * By default, we output a human-readable diff. If you want an executable script, pass the "script": true param.
+     */
+    migrateDiff(args: EngineArgs.MigrateDiffInput): Promise<EngineResults.MigrateDiffOutput>;
+    /**
+     * Mark a migration as applied in the migrations table.
+     * There are two possible outcomes:
+     * - The migration is already in the table, but in a failed state. In this case, we will mark it as rolled back, then create a new entry.
+     * - The migration is not in the table. We will create a new entry in the migrations table. The started_at and finished_at will be the same.
+     * If it is already applied, we return a user-facing error.
+     */
+    markMigrationApplied(args: EngineArgs.MarkMigrationAppliedInput): Promise<void>;
+    /**
+     * Mark an existing failed migration as rolled back in the migrations table. It will still be there, but ignored for all purposes except as audit trail.
+     */
+    markMigrationRolledBack(args: EngineArgs.MarkMigrationRolledBackInput): Promise<void>;
+    /**
+     * Try to make the database empty: no data and no schema.
+     * On most connectors, this is implemented by dropping and recreating the database.
+     * If that fails (most likely because of insufficient permissions),
+     * the engine attempts a “best effort reset” by inspecting the contents of the database and dropping them individually.
+     * Drop and recreate the database. The migrations will not be applied, as it would overlap with applyMigrations.
+     */
+    reset(): Promise<void>;
+    /**
+     * The command behind db push.
+     */
+    schemaPush(args: EngineArgs.SchemaPushInput): Promise<EngineResults.SchemaPush>;
+    /**
+     * SQL introspection that powers TypedSQL feature
+     * @param args
+     * @returns
+     */
+    introspectSql(args: EngineArgs.IntrospectSqlParams): Promise<EngineResults.IntrospectSqlOutput>;
+    stop(): void;
+    private rejectAll;
+    private registerCallback;
+    private handleResponse;
+    private init;
+    private internalInit;
+    private runCommand;
+    private getRPCPayload;
+}
+export {};

package/dist/migrate/src/SchemaEngineWasm.d.ts

@@ -0,0 +1,134 @@
+import type { ErrorCapturingSqlDriverAdapterFactory } from '@prisma/driver-adapter-utils';
+import { SchemaContext, wasm } from '@prisma/internals';
+import { SchemaEngine } from './SchemaEngine';
+import { EngineArgs } from './types';
+type SchemaEngineMethods = Omit<wasm.SchemaEngineWasm, 'free'>;
+export type SchemaEngineInput<M extends keyof SchemaEngineMethods> = Parameters<wasm.SchemaEngineWasm[M]>[0];
+export type SchemaEngineOutput<M extends keyof SchemaEngineMethods> = ReturnType<wasm.SchemaEngineWasm[M]>;
+interface SchemaEngineWasmSetupInput {
+    adapter: ErrorCapturingSqlDriverAdapterFactory;
+    enabledPreviewFeatures?: string[];
+    schemaContext?: SchemaContext;
+}
+export interface SchemaEngineWasmOptions extends Omit<SchemaEngineWasmSetupInput, 'adapter'> {
+    debug?: boolean;
+    engine: wasm.SchemaEngineWasm;
+}
+/**
+ * Wrapper around `@prisma/schema-engine-wasm`, which will eventually replace `SchemaEngineCLI`.
+ *
+ * TODOs:
+ * - Forward initial schema and preview features to the Wasm engine
+ * - Collect and forward logs to the CLI
+ * - Catch and throw "rich" connector errors
+ */
+export declare class SchemaEngineWasm implements SchemaEngine {
+    private engine;
+    private schemaContext?;
+    private enabledPreviewFeatures?;
+    isRunning: boolean;
+    private constructor();
+    static setup({ adapter, ...rest }: SchemaEngineWasmSetupInput): Promise<SchemaEngineWasm>;
+    private runCommand;
+    /**
+     * Apply the migrations from the migrations directory to the database.
+     * This is the command behind prisma migrate deploy.
+     */
+    applyMigrations(input: SchemaEngineInput<'applyMigrations'>): SchemaEngineOutput<'applyMigrations'>;
+    /**
+     * Create the next migration in the migrations history.
+     * If draft is false and there are no unexecutable steps, it will also apply the newly created migration.
+     * Note: This will use the shadow database on the connectors where we need one.
+     */
+    createMigration(input: SchemaEngineInput<'createMigration'>): SchemaEngineOutput<'createMigration'>;
+    /**
+     * Execute a database script directly on the specified live database.
+     * Note that this may not be defined on all connectors.
+     */
+    dbExecute(input: SchemaEngineInput<'dbExecute'>): Promise<null>;
+    /**
+     * Make the Schema engine panic. Only useful to test client error handling.
+     */
+    debugPanic(): Promise<never>;
+    /**
+     * The method called at the beginning of migrate dev to decide the course of action,
+     * based on the current state of the workspace.
+     * It acts as a wrapper around diagnoseMigrationHistory.
+     * Its role is to interpret the diagnostic output,
+     * and translate it to a concrete action to be performed by the CLI.
+     */
+    devDiagnostic(input: SchemaEngineInput<'devDiagnostic'>): SchemaEngineOutput<'devDiagnostic'>;
+    /**
+     * Read the contents of the migrations directory and the migrations table, and returns their relative statuses.
+     * At this stage, the Schema engine only reads,
+     * it does not write to the database nor the migrations directory, nor does it use a shadow database.
+     */
+    diagnoseMigrationHistory(input: SchemaEngineInput<'diagnoseMigrationHistory'>): SchemaEngineOutput<'diagnoseMigrationHistory'>;
+    /**
+     * Make sure the Schema engine can connect to the database from the Prisma schema.
+     */
+    ensureConnectionValidity(input: SchemaEngineInput<'ensureConnectionValidity'>): Promise<void>;
+    /**
+     * Development command for migrations.
+     * Evaluate the data loss induced by the next migration the engine would generate on the main database.
+     */
+    evaluateDataLoss(input: SchemaEngineInput<'evaluateDataLoss'>): SchemaEngineOutput<'evaluateDataLoss'>;
+    /**
+     * Get the database version for error reporting.
+     * If no argument is given, the version of the database associated to the Prisma schema provided
+     * in the constructor will be returned.
+     */
+    getDatabaseVersion(input?: SchemaEngineInput<'version'>): SchemaEngineOutput<'version'>;
+    /**
+     * Given a Prisma schema, introspect the database definitions and update the schema with the results.
+     * `compositeTypeDepth` is optional, and only required for MongoDB.
+     */
+    introspect({ schema, force, baseDirectoryPath, viewsDirectoryPath, compositeTypeDepth, namespaces, }: EngineArgs.IntrospectParams): SchemaEngineOutput<'introspect'>;
+    /**
+     * Compares two databases schemas from two arbitrary sources,
+     * and display the difference as either a human-readable summary,
+     * or an executable script that can be passed to dbExecute.
+     * Connection to a shadow database is only necessary when either the from or the to params is a migrations directory.
+     * Diffs have a direction. Which source is from and which is to matters.
+     * The resulting diff should be thought of as a migration from the schema in `args.from` to the schema in `args.to`.
+     * By default, we output a human-readable diff. If you want an executable script, pass the "script": true param.
+     */
+    migrateDiff(input: SchemaEngineInput<'diff'>): Promise<{
+        exitCode: number;
+    }>;
+    /**
+     * Mark a migration as applied in the migrations table.
+     * There are two possible outcomes:
+     * - The migration is already in the table, but in a failed state. In this case, we will mark it as rolled back, then create a new entry.
+     * - The migration is not in the table. We will create a new entry in the migrations table. The started_at and finished_at will be the same.
+     * If it is already applied, we return a user-facing error.
+     */
+    markMigrationApplied(input: SchemaEngineInput<'markMigrationApplied'>): Promise<void>;
+    /**
+     * Mark an existing failed migration as rolled back in the migrations table. It will still be there, but ignored for all purposes except as audit trail.
+     */
+    markMigrationRolledBack(input: SchemaEngineInput<'markMigrationRolledBack'>): Promise<void>;
+    /**
+     * Try to make the database empty: no data and no schema.
+     * On most connectors, this is implemented by dropping and recreating the database.
+     * If that fails (most likely because of insufficient permissions),
+     * the engine attempts a “best effort reset” by inspecting the contents of the database and dropping them individually.
+     * Drop and recreate the database. The migrations will not be applied, as it would overlap with applyMigrations.
+     */
+    reset(): Promise<void>;
+    /**
+     * The command behind db push.
+     */
+    schemaPush(input: SchemaEngineInput<'schemaPush'>): SchemaEngineOutput<'schemaPush'>;
+    /**
+     * SQL introspection that powers TypedSQL feature
+     * @param args
+     * @returns
+     */
+    introspectSql(input: SchemaEngineInput<'introspectSql'>): SchemaEngineOutput<'introspectSql'>;
+    /**
+     * Stop the engine.
+     */
+    stop(): void;
+}
+export {};

package/dist/migrate/src/commands/DbExecute.d.ts

@@ -3,6 +3,6 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class DbExecute implements Command {
     static new(): DbExecute;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/DbPull.d.ts

@@ -4,7 +4,7 @@ export declare class DbPull implements Command {
     static new(): DbPull;
     private static help;
     private urlToDatasource;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     private getWarningMessage;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/DbPush.d.ts

@@ -3,6 +3,6 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class DbPush implements Command {
     static new(): DbPush;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/MigrateDeploy.d.ts

@@ -3,6 +3,6 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class MigrateDeploy implements Command {
     static new(): MigrateDeploy;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/MigrateDev.d.ts

@@ -3,7 +3,7 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class MigrateDev implements Command {
     static new(): MigrateDev;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     private logResetReason;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/MigrateDiff.d.ts

@@ -3,6 +3,6 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class MigrateDiff implements Command {
     static new(): MigrateDiff;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/MigrateReset.d.ts

@@ -3,6 +3,6 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class MigrateReset implements Command {
     static new(): MigrateReset;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/MigrateResolve.d.ts

@@ -3,6 +3,6 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class MigrateResolve implements Command {
     static new(): MigrateResolve;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/commands/MigrateStatus.d.ts

@@ -3,6 +3,6 @@ import { Command, HelpError } from '@prisma/internals';
 export declare class MigrateStatus implements Command {
     static new(): MigrateStatus;
     private static help;
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
+    parse(argv: string[], config: PrismaConfigInternal<any>): Promise<string | Error>;
     help(error?: string): string | HelpError;
 }

package/dist/migrate/src/index.d.ts

@@ -12,7 +12,8 @@ export { MigrateReset } from './commands/MigrateReset';
 export { MigrateResolve } from './commands/MigrateResolve';
 export { MigrateStatus } from './commands/MigrateStatus';
 export { Migrate } from './Migrate';
-export { SchemaEngine } from './SchemaEngine';
+export { SchemaEngineCLI } from './SchemaEngineCLI';
+export { SchemaEngineWasm } from './SchemaEngineWasm';
 export * from './types';
 export { default as byline } from './utils/byline';
 export { getDatabaseVersionSafe } from './utils/getDatabaseVersionSafe';

package/dist/migrate/src/types.d.ts

@@ -50,7 +50,7 @@ export type HistoryDiagnostic = {
     unpersistedMigrationNames: string[];
 } | {
     diagnostic: 'historiesDiverge';
-    lastCommonMigrationName: string;
+    lastCommonMigrationName: string | null;
     unpersistedMigrationNames: string[];
     unappliedMigrationNames: string[];
 };
@@ -92,7 +92,7 @@ export declare namespace EngineArgs {
         schema: MigrateTypes.SchemasContainer;
         baseDirectoryPath: string;
         viewsDirectoryPath: string;
-        force?: Boolean;
+        force?: boolean;
         compositeTypeDepth?: number;
         namespaces?: string[];
     }
@@ -140,17 +140,14 @@ export declare namespace EngineArgs {
     };
     type MigrateDiffTargetSchemaDatamodel = MigrateTypes.Tagged<'schemaDatamodel', MigrateTypes.SchemasContainer>;
     type MigrateDiffTargetSchemaDatasource = MigrateTypes.Tagged<'schemaDatasource', MigrateTypes.SchemasWithConfigDir>;
-    type MigrateDiffTargetMigrations = {
-        tag: 'migrations';
-        migrationsList: MigrateTypes.MigrationList;
-    };
+    type MigrateDiffTargetMigrations = MigrateTypes.Tagged<'migrations', MigrateTypes.MigrationList>;
     export type MigrateDiffTarget = MigrateDiffTargetUrl | MigrateDiffTargetEmpty | MigrateDiffTargetSchemaDatamodel | MigrateDiffTargetSchemaDatasource | MigrateDiffTargetMigrations;
     export interface MigrateDiffInput {
         from: MigrateDiffTarget;
         to: MigrateDiffTarget;
         script: boolean;
-        shadowDatabaseUrl?: string;
-        exitCode?: boolean;
+        shadowDatabaseUrl: string | null;
+        exitCode: boolean | null;
     }
     export interface SchemaPushInput {
         schema: MigrateTypes.SchemasContainer;
@@ -179,8 +176,7 @@ export declare namespace EngineResults {
         migrationScript: string | null;
         extension: string;
     }
-    interface DbExecuteOutput {
-    }
+    type DbExecuteOutput = null;
     interface DevDiagnosticOutput {
         action: DevAction;
     }

package/dist/utils/getDatabaseVersionSafe.js

@@ -18,12 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var getDatabaseVersionSafe_exports = {};
 __export(getDatabaseVersionSafe_exports, {
-  getDatabaseVersionSafe: () => import_chunk_NIKXBMZL.getDatabaseVersionSafe
+  getDatabaseVersionSafe: () => import_chunk_344G2PKM.getDatabaseVersionSafe
 });
 module.exports = __toCommonJS(getDatabaseVersionSafe_exports);
-var import_chunk_NIKXBMZL = require("../chunk-NIKXBMZL.js");
-var import_chunk_D2DGSPW6 = require("../chunk-D2DGSPW6.js");
-var import_chunk_OEWQACEH = require("../chunk-OEWQACEH.js");
+var import_chunk_344G2PKM = require("../chunk-344G2PKM.js");
+var import_chunk_YSWLN2IJ = require("../chunk-YSWLN2IJ.js");
+var import_chunk_URKH6SE2 = require("../chunk-URKH6SE2.js");
+var import_chunk_PQKZ53DW = require("../chunk-PQKZ53DW.js");
+var import_chunk_23DZXSTI = require("../chunk-23DZXSTI.js");
+var import_chunk_I3LT2PO3 = require("../chunk-I3LT2PO3.js");
 var import_chunk_L6KOIJJ5 = require("../chunk-L6KOIJJ5.js");
+var import_chunk_IK3BVD3Y = require("../chunk-IK3BVD3Y.js");
+var import_chunk_OEWQACEH = require("../chunk-OEWQACEH.js");
 var import_chunk_SKRR5WT4 = require("../chunk-SKRR5WT4.js");
 var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");

package/dist/utils/introspectSql.js

@@ -18,12 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var introspectSql_exports = {};
 __export(introspectSql_exports, {
-  introspectSql: () => import_chunk_5LTDMS3H.introspectSql
+  introspectSql: () => import_chunk_CU5UT2ED.introspectSql
 });
 module.exports = __toCommonJS(introspectSql_exports);
-var import_chunk_5LTDMS3H = require("../chunk-5LTDMS3H.js");
-var import_chunk_D2DGSPW6 = require("../chunk-D2DGSPW6.js");
-var import_chunk_OEWQACEH = require("../chunk-OEWQACEH.js");
+var import_chunk_CU5UT2ED = require("../chunk-CU5UT2ED.js");
+var import_chunk_YSWLN2IJ = require("../chunk-YSWLN2IJ.js");
+var import_chunk_URKH6SE2 = require("../chunk-URKH6SE2.js");
+var import_chunk_PQKZ53DW = require("../chunk-PQKZ53DW.js");
+var import_chunk_23DZXSTI = require("../chunk-23DZXSTI.js");
+var import_chunk_I3LT2PO3 = require("../chunk-I3LT2PO3.js");
 var import_chunk_L6KOIJJ5 = require("../chunk-L6KOIJJ5.js");
+var import_chunk_IK3BVD3Y = require("../chunk-IK3BVD3Y.js");
+var import_chunk_OEWQACEH = require("../chunk-OEWQACEH.js");
 var import_chunk_SKRR5WT4 = require("../chunk-SKRR5WT4.js");
 var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");

package/dist/utils/listMigrations.js

@@ -18,8 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var listMigrations_exports = {};
 __export(listMigrations_exports, {
-  listMigrations: () => import_chunk_V6PVGSDJ.listMigrations
+  listMigrations: () => import_chunk_PQKZ53DW.listMigrations
 });
 module.exports = __toCommonJS(listMigrations_exports);
-var import_chunk_V6PVGSDJ = require("../chunk-V6PVGSDJ.js");
+var import_chunk_PQKZ53DW = require("../chunk-PQKZ53DW.js");
 var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/migrate",
-  "version": "6.6.0-dev.95",
+  "version": "6.6.0-dev.97",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "types": "dist/migrate/src/index.d.ts",
@@ -56,12 +56,13 @@
   "dependencies": {
     "@prisma/engines-version": "6.6.0-45.fbda4d61f6cc9c7361b803e72f3a0ffeb87db447",
     "prompts": "2.4.2",
-    "@prisma/client-generator-registry": "6.6.0-dev.95",
-    "@prisma/config": "6.6.0-dev.95",
-    "@prisma/debug": "6.6.0-dev.95",
-    "@prisma/generator": "6.6.0-dev.95",
-    "@prisma/internals": "6.6.0-dev.95",
-    "@prisma/get-platform": "6.6.0-dev.95"
+    "@prisma/driver-adapter-utils": "6.6.0-dev.97",
+    "@prisma/client-generator-registry": "6.6.0-dev.97",
+    "@prisma/config": "6.6.0-dev.97",
+    "@prisma/debug": "6.6.0-dev.97",
+    "@prisma/generator": "6.6.0-dev.97",
+    "@prisma/get-platform": "6.6.0-dev.97",
+    "@prisma/internals": "6.6.0-dev.97"
   },
   "files": [
     "README.md",