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

package/dist/internals/src/cli/getSchema.d.ts

@@ -1,31 +1,10 @@
 import type { GetSchemaResult, SuccessfulLookupResult } from '@prisma/schema-files-loader';
-import type { MultipleSchemas } from '../utils/schemaFileInput';
 type PackageJsonLookupResult = SuccessfulLookupResult | {
     ok: false;
     error: {
         kind: 'PackageJsonNotConfigured';
     };
 };
-export type SchemaPathFromConfig = {
-    /**
-     * Tell Prisma to use a single `.prisma` schema file.
-     */
-    kind: 'single';
-    /**
-     * The path to a single `.prisma` schema file.
-     */
-    filePath: string;
-} | {
-    /**
-     * Tell Prisma to use multiple `.prisma` schema files, via the `prismaSchemaFolder` preview feature.
-     */
-    kind: 'multi';
-    /**
-     * The path to a folder containing multiple `.prisma` schema files.
-     * All of the files in this folder will be used.
-     */
-    folderPath: string;
-};
 export type GetSchemaOptions = {
     cwd?: string;
     argumentName?: string;
@@ -36,7 +15,7 @@ export type GetSchemaOptions = {
  * @param schemaPathFromConfig
  * @param opts
  */
-export declare function getSchemaWithPath(schemaPathFromArgs?: string, schemaPathFromConfig?: SchemaPathFromConfig, { cwd, argumentName }?: GetSchemaOptions): Promise<GetSchemaResult>;
+export declare function getSchemaWithPath(schemaPathFromArgs?: string, schemaPathFromConfig?: string, { cwd, argumentName }?: GetSchemaOptions): Promise<GetSchemaResult>;
 /**
  * Loads the schema, returns null if it is not found
  * Throws an error if schema is specified explicitly in
@@ -47,7 +26,8 @@ export declare function getSchemaWithPath(schemaPathFromArgs?: string, schemaPat
  * @param opts
  * @returns
  */
-export declare function getSchemaWithPathOptional(schemaPathFromArgs?: string, schemaPathFromConfig?: SchemaPathFromConfig, { cwd, argumentName }?: GetSchemaOptions): Promise<GetSchemaResult | null>;
+export declare function getSchemaWithPathOptional(schemaPathFromArgs?: string, schemaPathFromConfig?: string, { cwd, argumentName }?: GetSchemaOptions): Promise<GetSchemaResult | null>;
+export declare function printSchemaLoadedMessage(schemaPath: string): void;
 export type PrismaConfig = {
     schema?: string;
     seed?: string;
@@ -57,9 +37,4 @@ export declare function getPrismaConfigFromPackageJson(cwd: string): Promise<{
     packagePath: string;
 } | null>;
 export declare function getSchemaFromPackageJson(cwd: string): Promise<PackageJsonLookupResult>;
-/**
- * Small helper that returns the directory which contains the `schema.prisma` file
- */
-export declare function getSchemaDir(schemaPathFromArgs?: string): Promise<string | null>;
-export declare function getSchema(schemaPathFromArgs?: string, schemaPathFromConfig?: SchemaPathFromConfig): Promise<MultipleSchemas>;
 export {};

package/dist/internals/src/cli/hashes.d.ts

@@ -1,9 +1,8 @@
-import { type SchemaPathFromConfig } from './getSchema';
 /**
  * Get a unique identifier for the project by hashing
  * the directory with `schema.prisma`
  */
-export declare function getProjectHash(schemaPathFromArgs: string | undefined, schemaPathFromConfig: SchemaPathFromConfig | undefined): Promise<string>;
+export declare function getProjectHash(schemaPathFromArgs: string | undefined, schemaPathFromConfig: string | undefined): Promise<string>;
 /**
  * Get a unique identifier for the CLI installation path
  * which can be either global or local (in project's node_modules)

package/dist/internals/src/cli/schemaContext.d.ts

@@ -0,0 +1,59 @@
+import { DataSource, GeneratorConfig } from '@prisma/generator';
+import { GetSchemaResult, LoadedFile } from '@prisma/schema-files-loader';
+export type SchemaContext = {
+    /**
+     * All loaded schema files and their paths.
+     */
+    schemaFiles: LoadedFile[];
+    /**
+     * The root directory of the schema files.
+     * Either set explicitly from a schema folder based config or the parent directory of the schema.prisma file.
+     */
+    schemaRootDir: string;
+    /**
+     * The directory of the schema.prisma file that contains the datasource block.
+     * Some relative paths like SQLite paths or SSL file paths are resolved relative to it.
+     */
+    primaryDatasourceDirectory: string;
+    /**
+     * The path that shall be printed in user facing logs messages informing them from where the schema was loaded.
+     */
+    loadedFromPathForLogMessages: string;
+    /**
+     * The datasource extracted from the Prisma schema. So far we only support a single datasource block.
+     */
+    primaryDatasource: DataSource | undefined;
+    /**
+     * Warnings that were raised during Prisma schema parsing.
+     */
+    warnings: string[] | [];
+    /**
+     * The datasources extracted from the Prisma schema. Prefer to use primaryDatasource for most cases.
+     */
+    datasources: DataSource[] | [];
+    /**
+     * The generators extracted from the Prisma schema.
+     */
+    generators: GeneratorConfig[] | [];
+    schemaPath: string;
+};
+type LoadSchemaContextOptions = {
+    schemaPathFromArg?: string;
+    schemaPathFromConfig?: string;
+    printLoadMessage?: boolean;
+    ignoreEnvVarErrors?: boolean;
+    allowNull?: boolean;
+    schemaPathArgumentName?: string;
+    cwd?: string;
+};
+export declare function loadSchemaContext(opts: LoadSchemaContextOptions & {
+    allowNull: true;
+}): Promise<SchemaContext | null>;
+export declare function loadSchemaContext(opts?: LoadSchemaContextOptions): Promise<SchemaContext>;
+export declare function processSchemaResult({ schemaResult, printLoadMessage, ignoreEnvVarErrors, cwd, }: {
+    schemaResult: GetSchemaResult;
+    printLoadMessage?: boolean;
+    ignoreEnvVarErrors?: boolean;
+    cwd?: string;
+}): Promise<SchemaContext>;
+export {};

package/dist/internals/src/client/getClientEngineType.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorConfig } from '@prisma/generator-helper';
+import type { GeneratorConfig } from '@prisma/generator';
 export declare enum ClientEngineType {
     Library = "library",
     Binary = "binary",

package/dist/internals/src/convertCredentials.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectorType } from '@prisma/generator-helper';
+import type { ConnectorType } from '@prisma/generator';
 import type { DatabaseCredentials } from './types';
 export declare function credentialsToUri(credentials: DatabaseCredentials): string;
 export declare function uriToCredentials(connectionString: string): DatabaseCredentials;

package/dist/internals/src/engine-commands/getConfig.d.ts

@@ -1,4 +1,4 @@
-import type { DataSource, EnvValue, GeneratorConfig } from '@prisma/generator-helper';
+import type { DataSource, EnvValue, GeneratorConfig } from '@prisma/generator';
 import { type SchemaFileInput } from '../utils/schemaFileInput';
 import { QueryEngineErrorInit } from './queryEngineCommons';
 export interface GetConfigResponse {
@@ -16,10 +16,6 @@ interface GetConfigValidationError {
 }
 export type GetConfigOptions = {
     datamodel: SchemaFileInput;
-    cwd?: string;
-    prismaPath?: string;
-    datamodelPath?: string;
-    retry?: number;
     ignoreEnvVarErrors?: boolean;
 };
 export declare class GetConfigError extends Error {

package/dist/internals/src/engine-commands/getDmmf.d.ts

@@ -1,4 +1,5 @@
-import type { DataSource, DMMF, GeneratorConfig } from '@prisma/generator-helper';
+import type * as DMMF from '@prisma/dmmf';
+import type { DataSource, GeneratorConfig } from '@prisma/generator';
 import { type SchemaFileInput } from '../utils/schemaFileInput';
 import { QueryEngineErrorInit } from './queryEngineCommons';
 export interface ConfigMetaFormat {
@@ -7,11 +8,7 @@ export interface ConfigMetaFormat {
     warnings: string[];
 }
 export type GetDMMFOptions = {
-    datamodel?: SchemaFileInput;
-    cwd?: string;
-    prismaPath?: string;
-    datamodelPath?: string;
-    retry?: number;
+    datamodel: SchemaFileInput;
     previewFeatures?: string[];
 };
 export declare class GetDmmfError extends Error {

package/dist/internals/src/engine-commands/lintSchema.d.ts

@@ -19,7 +19,7 @@ export type LintDiagnostic = LintWarning | LintError;
  * This function may panic, but it won't throw any standard error.
  */
 export declare function lintSchema({ schemas }: LintSchemaParams): LintDiagnostic[];
-export declare function handleLintPanic<T>(tryCb: () => T, { schemas }: LintSchemaParams): T;
+export declare function handleLintPanic<T>(tryCb: () => T): T;
 export declare function getLintWarnings(lintDiagnostics: LintDiagnostic[]): LintWarning[];
 export declare function getLintWarningsAsText(lintDiagnostics: LintDiagnostic[]): string;
 export declare function warningToString(warning: LintDiagnostic): string;

package/dist/internals/src/errorReporting.d.ts

@@ -16,7 +16,6 @@ export interface CreateErrorReportInput {
     operatingSystem: string;
     platform: string;
     rustStackTrace: string;
-    schemaFile?: string;
     fingerprint?: string;
     sqlDump?: string;
     dbVersion?: string;

package/dist/internals/src/get-generators/getGenerators.d.ts

@@ -1,17 +1,32 @@
-import type { BinaryTargetsEnvValue, EngineType, GeneratorConfig, SqlQueryOutput } from '@prisma/generator-helper';
+import type { BinaryTargetsEnvValue, EngineType, Generator as IGenerator, GeneratorConfig, SqlQueryOutput } from '@prisma/generator';
 import type { BinaryTarget } from '@prisma/get-platform';
+import { SchemaContext } from '..';
 import { Generator } from '../Generator';
-import type { GeneratorPaths } from './generatorResolvers/generatorResolvers';
-export type ProviderAliases = {
-    [alias: string]: GeneratorPaths;
-};
 type BinaryPathsOverride = {
     [P in EngineType]?: string;
 };
+export type GeneratorRegistryEntry = {
+    type: 'rpc';
+    generatorPath: string;
+    isNode?: boolean;
+} | {
+    type: 'in-process';
+    generator: IGenerator;
+};
+export type GeneratorRegistry = Record<string, GeneratorRegistryEntry>;
+export type ProviderAliases = {
+    [alias: string]: {
+        generatorPath: string;
+        isNode?: boolean;
+    };
+};
 export type GetGeneratorOptions = {
-    schemaPath: string;
+    /** @deprecated Pass a schemaContext instead. Kept for compatibility with prisma studio. */
+    schemaPath?: string;
+    schemaContext?: SchemaContext;
+    registry: GeneratorRegistry;
+    /** @deprecated Use `registry` instead. Kept for compatibility with Prisma Studio. */
     providerAliases?: ProviderAliases;
-    cliVersion?: string;
     version?: string;
     printDownloadProgress?: boolean;
     overrideGenerators?: GeneratorConfig[];
@@ -27,8 +42,6 @@ export type GetGeneratorOptions = {
  * Makes sure that all generators have the binaries they deserve and returns a
  * `Generator` class per generator defined in the schema.prisma file.
  * In other words, this is basically a generator factory function.
- * @param schemaPath Path to schema.prisma
- * @param aliases Aliases like `prisma-client-js` -> `node_modules/@prisma/client/generator-build/index.js`
  */
 export declare function getGenerators(options: GetGeneratorOptions): Promise<Generator[]>;
 type NeededVersions = {

package/dist/internals/src/get-generators/utils/binaryTypeToEngineType.d.ts

@@ -1,3 +1,3 @@
 import { BinaryType } from '@prisma/fetch-engine';
-import type { EngineType } from '@prisma/generator-helper';
+import type { EngineType } from '@prisma/generator';
 export declare function binaryTypeToEngineType(binaryType: BinaryType): EngineType;

package/dist/internals/src/get-generators/utils/engineTypeToBinaryType.d.ts

@@ -1,3 +1,3 @@
 import { BinaryType } from '@prisma/fetch-engine';
-import type { EngineType } from '@prisma/generator-helper';
+import type { EngineType } from '@prisma/generator';
 export declare function engineTypeToBinaryType(engineType: EngineType): BinaryType;

package/dist/internals/src/get-generators/utils/fixBinaryTargets.d.ts

@@ -1,3 +1,3 @@
-import { BinaryTargetsEnvValue } from '@prisma/generator-helper';
+import { BinaryTargetsEnvValue } from '@prisma/generator';
 import { BinaryTarget } from '@prisma/get-platform';
 export declare function fixBinaryTargets(schemaBinaryTargets: BinaryTargetsEnvValue[], runtimeBinaryTarget: BinaryTarget | string): BinaryTargetsEnvValue[];

package/dist/internals/src/get-generators/utils/getBinaryPathsByVersion.d.ts

@@ -1,3 +1,3 @@
-import type { BinaryPaths } from '@prisma/generator-helper';
+import type { BinaryPaths } from '@prisma/generator';
 import type { GetBinaryPathsByVersionInput } from '../getGenerators';
 export declare function getBinaryPathsByVersion({ neededVersions, binaryTarget, version, printDownloadProgress, skipDownload, binaryPathsOverride, }: GetBinaryPathsByVersionInput): Promise<Record<string, BinaryPaths>>;

package/dist/internals/src/get-generators/utils/getEngineVersionForGenerator.d.ts

@@ -1,2 +1,2 @@
-import type { GeneratorManifest } from '@prisma/generator-helper';
+import type { GeneratorManifest } from '@prisma/generator';
 export declare function getEngineVersionForGenerator(manifest?: GeneratorManifest, defaultVersion?: string | undefined): string;

package/dist/internals/src/get-generators/utils/printGeneratorConfig.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryTargetsEnvValue, GeneratorConfig } from '@prisma/generator-helper';
+import type { BinaryTargetsEnvValue, GeneratorConfig } from '@prisma/generator';
 export declare function printGeneratorConfig(config: GeneratorConfig): string;
 export declare class GeneratorConfigClass {
     private readonly config;

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

@@ -1,10 +1,12 @@
 export { checkUnsupportedDataProxy } from './cli/checkUnsupportedDataProxy';
+export { type DirectoryConfig, inferDirectoryConfig } from './cli/directoryConfig';
 export { getGeneratorSuccessMessage } from './cli/getGeneratorSuccessMessage';
-export { getPrismaConfigFromPackageJson, getSchema, getSchemaDir, type GetSchemaOptions, getSchemaWithPath, getSchemaWithPathOptional, type SchemaPathFromConfig, } from './cli/getSchema';
+export { getPrismaConfigFromPackageJson, type GetSchemaOptions, getSchemaWithPath, getSchemaWithPathOptional, printSchemaLoadedMessage, } from './cli/getSchema';
 export { getTypescriptVersion } from './cli/getTypescriptVersion';
 export { getCLIPathHash, getProjectHash } from './cli/hashes';
 export { unknownCommand } from './cli/Help';
 export { HelpError } from './cli/Help';
+export { loadSchemaContext, processSchemaResult, type SchemaContext } from './cli/schemaContext';
 export type { Command, Commands, CompiledGeneratorDefinition, Dictionary, GeneratorConfig, GeneratorDefinition, GeneratorDefinitionWithPackage, GeneratorFunction, GeneratorOptions, } from './cli/types';
 export { arg, format, isError } from './cli/utils';
 export { ClientEngineType, DEFAULT_CLIENT_ENGINE_TYPE, getClientEngineType } from './client/getClientEngineType';
@@ -13,19 +15,17 @@ export * from './engine-commands';
 export { resolveUrl } from './engine-commands/getConfig';
 export { relativizePathInPSLError } from './engine-commands/relativizePathInPSLError';
 export { Generator } from './Generator';
-export type { GeneratorPaths } from './get-generators/generatorResolvers/generatorResolvers';
-export { getPackageCmd } from './get-generators/generatorResolvers/prisma-client-js/auto-installation/getPackageCmd';
-export type { ProviderAliases } from './get-generators/getGenerators';
-export { getGenerator, getGenerators } from './get-generators/getGenerators';
+export { type GeneratorRegistry, type GeneratorRegistryEntry, getGenerator, getGenerators, } from './get-generators/getGenerators';
 export { fixBinaryTargets } from './get-generators/utils/fixBinaryTargets';
 export { printGeneratorConfig } from './get-generators/utils/printGeneratorConfig';
 export { getPackedPackage } from './getPackedPackage';
 export { highlightDatamodel, highlightSql, highlightTS } from './highlight/highlight';
 export * as logger from './logger';
 export type { MigrateTypes } from './migrateTypes';
-export { ErrorArea, isRustPanic, RustPanic } from './panic';
+export { ErrorArea, getWasmError, isRustPanic, isWasmPanic, RustPanic } from './panic';
 export { BinaryType } from './resolveBinary';
 export { engineEnvVarMap, resolveBinary } from './resolveBinary';
+export { resolvePkg } from './resolvePkg';
 export type { SchemaEngineLogLine } from './schemaEngineCommands';
 export { canConnectToDatabase, createDatabase, dropDatabase } from './schemaEngineCommands';
 export { SchemaEngineExitCode } from './schemaEngineCommands';
@@ -75,7 +75,7 @@ export { longestCommonPathPrefix, pathToPosix } from './utils/path';
 export { pick } from './utils/pick';
 export { printConfigWarnings } from './utils/printConfigWarnings';
 export { isPrismaPostgres, PRISMA_POSTGRES_PROTOCOL, PRISMA_POSTGRES_PROVIDER } from './utils/prismaPostgres';
-export { debugMultipleSchemaPaths, debugMultipleSchemas, extractSchemaContent, type SchemaFileInput, toMultipleSchemas, } from './utils/schemaFileInput';
+export { extractSchemaContent, type SchemaFileInput } from './utils/schemaFileInput';
 export { type MultipleSchemas } from './utils/schemaFileInput';
 export { serializeQueryEngineName } from './utils/serializeQueryEngineName';
 export { setClassName } from './utils/setClassName';
@@ -84,7 +84,8 @@ export { type LoadedEnv, tryLoadEnvs } from './utils/tryLoadEnvs';
 export { vercelPkgPathRegex } from './utils/vercelPkgPathRegex';
 export { warnOnce } from './warnOnce';
 export * as wasm from './wasm';
-export type { EnvPaths } from '@prisma/generator-helper';
+export { wasmSchemaEngineLoader } from './WasmSchemaEngineLoader';
+export type { EnvPaths } from '@prisma/generator';
 export type { BinaryTarget } from '@prisma/get-platform';
 export { getBinaryTargetForCurrentPlatform, getNodeAPIName } from '@prisma/get-platform';
 export type { GetSchemaResult } from '@prisma/schema-files-loader';

package/dist/internals/src/migrateTypes.d.ts

@@ -1,4 +1,67 @@
 export declare namespace MigrateTypes {
+    type MigrationDirectory = {
+        /**
+         * Relative path to a migration directory from `baseDir`.
+         * E.g., `./20201117144659_test`.
+         */
+        path: string;
+        /**
+         * Description of the migration file in the directory.
+         */
+        migrationFile: {
+            /**
+             * Relative path to the migration file from `path`.
+             */
+            path: 'migration.sql';
+            /**
+             * Content of the migration file.
+             * E.g.,
+             * ```sql
+             * -- CreateTable
+             * CREATE TABLE "Blog" (
+             *     "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+             *
+             *     "viewCount20" INTEGER NOT NULL
+             * );
+             * ```
+             */
+            content: Tagged<'ok', {
+                value: string;
+            }> | Tagged<'error', {
+                value: string;
+            }>;
+        };
+    };
+    type MigrationLockfile = {
+        /**
+         * Relative path to the lockfile from `baseDir`.
+         */
+        path: 'migration_lock.toml';
+        /**
+         * Content of the lockfile, if it exists.
+         * E.g.,
+         * ```toml
+         * # Please do not edit this file manually
+         * provider = "sqlite"
+         * ```
+         */
+        content: string | null;
+    };
+    type MigrationList = {
+        /**
+         * Absolute path to the base directory of Prisma migrations.
+         * E.g., `/usr/src/app/prisma/migrations`.
+         */
+        baseDir: string;
+        /**
+         * Description of the lockfile, which may or may not exist.
+         */
+        lockfile: MigrationLockfile;
+        /**
+         * Description of the migration directories.
+         */
+        migrationDirectories: Array<MigrationDirectory>;
+    };
     type SchemaContainer = {
         path: string;
         content: string;

package/dist/internals/src/panic.d.ts

@@ -1,13 +1,10 @@
-import { MultipleSchemas } from './utils/schemaFileInput';
 export declare class RustPanic extends Error {
     readonly __typename = "RustPanic";
     request: any;
     rustStack: string;
     area: ErrorArea;
-    schemaPath?: string;
-    schema?: MultipleSchemas;
     introspectionUrl?: string;
-    constructor(message: string, rustStack: string, request: any, area: ErrorArea, schemaPath?: string, schema?: MultipleSchemas, introspectionUrl?: string);
+    constructor(message: string, rustStack: string, request: any, area: ErrorArea, introspectionUrl?: string);
 }
 export declare function isRustPanic(e: Error): e is RustPanic;
 export declare enum ErrorArea {

package/dist/internals/src/resolvePkg.d.ts

@@ -0,0 +1,7 @@
+import resolve from 'resolve';
+/**
+ * Alternative to `require.resolve` that returns undefined instead of throwing.
+ * It also enables preserving symlinks, which is not possible with the original
+ * `require.resolve`. This variant will find the _root_ of a package.
+ */
+export declare function resolvePkg(id: string, options: resolve.AsyncOpts): Promise<string | undefined>;

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

@@ -1,4 +1,4 @@
-import type { ConnectorType } from '@prisma/generator-helper';
+import type { ConnectorType } from '@prisma/generator';
 export interface DatabaseCredentials {
     type: ConnectorType;
     host?: string;

package/dist/internals/src/utils/extractPreviewFeatures.d.ts

@@ -1,2 +1,2 @@
-import type { ConfigMetaFormat } from '../engine-commands';
-export declare function extractPreviewFeatures(config: ConfigMetaFormat): string[];
+import type { GeneratorConfig } from '@prisma/generator';
+export declare function extractPreviewFeatures(generators: GeneratorConfig[]): string[];

package/dist/internals/src/utils/getEnvPaths.d.ts

@@ -1,4 +1,4 @@
-import { EnvPaths } from '@prisma/generator-helper';
+import { EnvPaths } from '@prisma/generator';
 /**
  *  1. Search in project root
  *  1. Schema

package/dist/internals/src/utils/parseEnvValue.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryTargetsEnvValue, EnvValue } from '@prisma/generator-helper';
+import type { BinaryTargetsEnvValue, EnvValue } from '@prisma/generator';
 /**
  * Parses an EnvValue (example: Provider) and return the string value
  *

package/dist/internals/src/utils/schemaFileInput.d.ts

@@ -2,8 +2,4 @@ export type SingleSchema = string;
 export type MultipleSchemaTuple = [filename: string, content: string];
 export type MultipleSchemas = Array<MultipleSchemaTuple>;
 export type SchemaFileInput = SingleSchema | MultipleSchemas;
-export declare const schemaToStringDebug: (schemaFileInput: SchemaFileInput | unknown) => string | undefined;
-export declare function toMultipleSchemas(input: SchemaFileInput | undefined): MultipleSchemas | undefined;
-export declare function debugMultipleSchemas(multipleSchemas: MultipleSchemas): string;
-export declare function debugMultipleSchemaPaths(multipleSchemas: MultipleSchemas): string;
 export declare function extractSchemaContent(multipleSchemas: MultipleSchemas): string[];

package/dist/internals/src/utils/toSchemasContainer.d.ts

@@ -1,6 +1,5 @@
-import { GetSchemaResult } from '@prisma/schema-files-loader';
-import { ConfigMetaFormat } from '../engine-commands';
+import { SchemaContext } from '../cli/schemaContext';
 import { MigrateTypes } from '../migrateTypes';
 import { MultipleSchemas } from './schemaFileInput';
 export declare function toSchemasContainer(schemas: MultipleSchemas): MigrateTypes.SchemasContainer;
-export declare function toSchemasWithConfigDir(getSchemaResult: GetSchemaResult, config: ConfigMetaFormat): MigrateTypes.SchemasWithConfigDir;
+export declare function toSchemasWithConfigDir(schemaContext: SchemaContext): MigrateTypes.SchemasWithConfigDir;

package/dist/internals/src/wasm.d.ts

@@ -1,3 +1,5 @@
 import prismaSchemaWasm from '@prisma/prisma-schema-wasm';
-export { prismaSchemaWasm };
+import type { SchemaEngine as SchemaEngineWasm } from '@prisma/schema-engine-wasm';
+export { prismaSchemaWasm, SchemaEngineWasm };
 export declare const prismaSchemaWasmVersion: string;
+export declare const schemaEngineWasmVersion: string;

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

@@ -1,16 +1,26 @@
-import { type GetSchemaResult } from '@prisma/internals';
-import { SchemaEngine } from './SchemaEngine';
+import type { ErrorCapturingSqlDriverAdapterFactory } from '@prisma/driver-adapter-utils';
+import { MigrateTypes, SchemaContext } from '@prisma/internals';
+import type { SchemaEngine } from './SchemaEngine';
 import type { EngineArgs, EngineResults } from './types';
 import { DatasourceInfo } from './utils/ensureDatabaseExists';
+interface MigrateSetupInput {
+    adapter?: ErrorCapturingSqlDriverAdapterFactory;
+    migrationsDirPath?: string;
+    enabledPreviewFeatures?: string[];
+    schemaContext?: SchemaContext;
+}
 export declare class Migrate {
-    engine: SchemaEngine;
-    private schemaPath?;
+    readonly engine: SchemaEngine;
+    private schemaContext?;
     migrationsDirectoryPath?: string;
-    constructor(schemaPath?: string, enabledPreviewFeatures?: string[]);
+    private constructor();
+    static setup({ adapter, ...rest }: MigrateSetupInput): Promise<Migrate>;
     stop(): void;
-    getPrismaSchema(): Promise<GetSchemaResult>;
+    getPrismaSchema(): MigrateTypes.SchemasContainer;
     reset(): Promise<void>;
-    createMigration(params: EngineArgs.CreateMigrationInput): Promise<EngineResults.CreateMigrationOutput>;
+    createMigration(params: Omit<EngineArgs.CreateMigrationInput, 'migrationsList'>): Promise<{
+        generatedMigrationName: string | undefined;
+    }>;
     diagnoseMigrationHistory({ optInToShadowDatabase, }: {
         optInToShadowDatabase: boolean;
     }): Promise<EngineResults.DiagnoseMigrationHistoryOutput>;
@@ -29,3 +39,4 @@ export declare class Migrate {
     }): Promise<EngineResults.SchemaPush>;
     tryToRunGenerate(datasourceInfo: DatasourceInfo): Promise<void>;
 }
+export {};