@prisma/migrate 6.6.0-dev.1 → 6.6.0-dev.100

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

@@ -1,49 +1,27 @@
 import { type MigrateTypes } from '@prisma/internals';
 import type { EngineArgs, EngineResults } from './types';
-export interface SchemaEngineOptions {
-    schemaPath?: string;
-    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 schemaPath?;
-    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, schemaPath, 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, 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,11 +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>;
-    /**
-     * List the names of the migrations in the migrations directory.
-     */
-    listMigrationDirectories(args: EngineArgs.ListMigrationDirectoriesInput): Promise<EngineResults.ListMigrationDirectoriesOutput>;
+    migrateDiff(input: EngineArgs.MigrateDiffInput): Promise<EngineResults.MigrateDiffOutput>;
     /**
      * Mark a migration as applied in the migrations table.
      * There are two possible outcomes:
@@ -105,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.
@@ -121,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,9 +12,9 @@ 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';
-export { getSchemaPathAndPrint, printSchemaLoadedMessage } from './utils/getSchemaPathAndPrint';
 export { introspectSql, type IntrospectSqlError, type IntrospectSqlInput, type IntrospectSqlResult, } from './utils/introspectSql';

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

@@ -1,4 +1,4 @@
-import type { SqlQueryOutput } from '@prisma/generator-helper';
+import type { ActiveConnectorType, SqlQueryOutput } from '@prisma/generator';
 import type { MigrateTypes } from '@prisma/internals';
 import type { IntrospectionViewDefinition } from './views/handleViewsIO';
 export interface RpcRequestResponse {
@@ -50,7 +50,7 @@ export type HistoryDiagnostic = {
     unpersistedMigrationNames: string[];
 } | {
     diagnostic: 'historiesDiverge';
-    lastCommonMigrationName: string;
+    lastCommonMigrationName: string | null;
     unpersistedMigrationNames: string[];
     unappliedMigrationNames: string[];
 };
@@ -69,13 +69,13 @@ export declare namespace EngineArgs {
      * These RPCs need a sourceConfig, therefore a db connection to function
      */
     export interface ApplyMigrationsInput {
-        migrationsDirectoryPath: string;
+        migrationsList: MigrateTypes.MigrationList;
     }
     export interface CreateMigrationInput {
-        migrationsDirectoryPath: string;
+        migrationsList: MigrateTypes.MigrationList;
         schema: MigrateTypes.SchemasContainer;
         draft: boolean;
-        migrationName?: string;
+        migrationName: string;
     }
     export interface CreateDatabaseInput {
         datasource: MigrateTypes.DatasourceParam;
@@ -91,7 +91,8 @@ export declare namespace EngineArgs {
     export interface IntrospectParams {
         schema: MigrateTypes.SchemasContainer;
         baseDirectoryPath: string;
-        force?: Boolean;
+        viewsDirectoryPath: string;
+        force?: boolean;
         compositeTypeDepth?: number;
         namespaces?: string[];
     }
@@ -110,24 +111,24 @@ export declare namespace EngineArgs {
         views: IntrospectionViewDefinition[] | null;
     }
     export interface DevDiagnosticInput {
-        migrationsDirectoryPath: string;
+        migrationsList: MigrateTypes.MigrationList;
     }
     export interface DiagnoseMigrationHistoryInput {
-        migrationsDirectoryPath: string;
+        migrationsList: MigrateTypes.MigrationList;
         optInToShadowDatabase: boolean;
     }
     export interface EnsureConnectionValidityInput {
         datasource: MigrateTypes.DatasourceParam;
     }
     export interface EvaluateDataLossInput {
-        migrationsDirectoryPath: string;
+        migrationsList: MigrateTypes.MigrationList;
         schema: MigrateTypes.SchemasContainer;
     }
     export interface ListMigrationDirectoriesInput {
         migrationsDirectoryPath: string;
     }
     export interface MarkMigrationAppliedInput {
-        migrationsDirectoryPath: string;
+        migrationsList: MigrateTypes.MigrationList;
         migrationName: string;
     }
     export interface MarkMigrationRolledBackInput {
@@ -139,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';
-        path: string;
-    };
+    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;
@@ -173,10 +171,12 @@ export declare namespace EngineResults {
         database_name: string;
     }
     interface CreateMigrationOutput {
-        generatedMigrationName: string | null;
-    }
-    interface DbExecuteOutput {
+        connectorType: ActiveConnectorType;
+        generatedMigrationName: string;
+        migrationScript: string | null;
+        extension: string;
     }
+    type DbExecuteOutput = null;
     interface DevDiagnosticOutput {
         action: DevAction;
     }

package/dist/migrate/src/utils/createMigration.d.ts

@@ -0,0 +1,21 @@
+import type { ActiveConnectorType } from '@prisma/generator';
+import type { MigrateTypes } from '@prisma/internals';
+type CreateMigrationInput = {
+    baseDir: string;
+    generatedMigrationName: string;
+};
+export declare function createMigration({ baseDir, generatedMigrationName }: CreateMigrationInput): Promise<string>;
+type WriteMigrationScriptInput = {
+    baseDir: string;
+    migrationName: string;
+    extension: string;
+    script: string;
+};
+export declare function writeMigrationScript({ baseDir, extension, migrationName, script, }: WriteMigrationScriptInput): Promise<void>;
+type WriteMigrationLockfileInput = {
+    baseDir: string;
+    connectorType: ActiveConnectorType;
+    lockfile: Omit<MigrateTypes.MigrationLockfile, 'content'>;
+};
+export declare function writeMigrationLockfile({ baseDir, connectorType, lockfile }: WriteMigrationLockfileInput): Promise<void>;
+export {};