@prisma/migrate 6.6.0-dev.5 → 6.6.0-dev.52

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';
@@ -75,7 +77,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 +86,7 @@ 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 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: Error;
+            }>;
+        };
+    };
+    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/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/migrate/src/Migrate.d.ts

@@ -1,16 +1,18 @@
-import { type GetSchemaResult } from '@prisma/internals';
+import { MigrateTypes, SchemaContext } from '@prisma/internals';
 import { SchemaEngine } from './SchemaEngine';
 import type { EngineArgs, EngineResults } from './types';
 import { DatasourceInfo } from './utils/ensureDatabaseExists';
 export declare class Migrate {
     engine: SchemaEngine;
-    private schemaPath?;
+    private schemaContext?;
     migrationsDirectoryPath?: string;
-    constructor(schemaPath?: string, enabledPreviewFeatures?: string[]);
+    constructor(schemaContext?: SchemaContext, migrationsDirPath?: string, enabledPreviewFeatures?: string[]);
     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>;

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

@@ -1,7 +1,7 @@
-import { type MigrateTypes } from '@prisma/internals';
+import { type MigrateTypes, SchemaContext } from '@prisma/internals';
 import type { EngineArgs, EngineResults } from './types';
 export interface SchemaEngineOptions {
-    schemaPath?: string;
+    schemaContext?: SchemaContext;
     debug?: boolean;
     enabledPreviewFeatures?: string[];
 }
@@ -12,7 +12,7 @@ export declare class EngineError extends Error {
 export declare class SchemaEngine {
     private debug;
     private child?;
-    private schemaPath?;
+    private schemaContext?;
     private listeners;
     /**  _All_ the logs from the engine process. */
     private messages;
@@ -23,7 +23,7 @@ export declare class SchemaEngine {
     private enabledPreviewFeatures?;
     private latestSchema?;
     isRunning: boolean;
-    constructor({ debug, schemaPath, enabledPreviewFeatures }: SchemaEngineOptions);
+    constructor({ debug, schemaContext, enabledPreviewFeatures }: SchemaEngineOptions);
     /**
      * Apply the migrations from the migrations directory to the database.
      * This is the command behind prisma migrate deploy.
@@ -82,7 +82,7 @@ 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
+    introspect({ schema, force, baseDirectoryPath, viewsDirectoryPath, compositeTypeDepth, // cannot be undefined
     namespaces, }: EngineArgs.IntrospectParams): Promise<EngineArgs.IntrospectResult>;
     /**
      * Compares two databases schemas from two arbitrary sources,
@@ -94,10 +94,6 @@ export declare class SchemaEngine {
      * 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>;
     /**
      * Mark a migration as applied in the migrations table.
      * There are two possible outcomes:

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

@@ -16,5 +16,4 @@ export { SchemaEngine } from './SchemaEngine';
 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 {
@@ -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,6 +91,7 @@ export declare namespace EngineArgs {
     export interface IntrospectParams {
         schema: MigrateTypes.SchemasContainer;
         baseDirectoryPath: string;
+        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 {
@@ -141,7 +142,7 @@ export declare namespace EngineArgs {
     type MigrateDiffTargetSchemaDatasource = MigrateTypes.Tagged<'schemaDatasource', MigrateTypes.SchemasWithConfigDir>;
     type MigrateDiffTargetMigrations = {
         tag: 'migrations';
-        path: string;
+        migrationsList: MigrateTypes.MigrationList;
     };
     export type MigrateDiffTarget = MigrateDiffTargetUrl | MigrateDiffTargetEmpty | MigrateDiffTargetSchemaDatamodel | MigrateDiffTargetSchemaDatasource | MigrateDiffTargetMigrations;
     export interface MigrateDiffInput {
@@ -173,7 +174,10 @@ export declare namespace EngineResults {
         database_name: string;
     }
     interface CreateMigrationOutput {
-        generatedMigrationName: string | null;
+        connectorType: ActiveConnectorType;
+        generatedMigrationName: string;
+        migrationScript: string | null;
+        extension: string;
     }
     interface DbExecuteOutput {
     }

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 {};

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

@@ -1,3 +1,4 @@
+import { DataSource } from '@prisma/generator';
 import type { DatabaseCredentials } from '@prisma/internals';
 import { ConnectorType } from './printDatasources';
 export type MigrateAction = 'create' | 'apply' | 'unapply' | 'dev' | 'push';
@@ -12,12 +13,9 @@ export type DatasourceInfo = {
     schemas?: string[];
     configDir?: string;
 };
-export declare function getDatasourceInfo({ schemaPath, throwIfEnvError, }?: {
-    schemaPath?: string;
-    throwIfEnvError?: boolean;
-}): Promise<DatasourceInfo>;
-export declare function ensureCanConnectToDatabase(schemaPath?: string): Promise<Boolean | Error>;
-export declare function ensureDatabaseExists(action: MigrateAction, schemaPath?: string): Promise<string | undefined>;
+export declare function parseDatasourceInfo(datasource: DataSource | undefined): DatasourceInfo;
+export declare function ensureCanConnectToDatabase(datasource: DataSource | undefined): Promise<Boolean | Error>;
+export declare function ensureDatabaseExists(datasource: DataSource | undefined): Promise<string | undefined>;
 export declare function getDbLocation(credentials: DatabaseCredentials): string | undefined;
 /**
  * Return a pretty version of a "provider" (with uppercase characters)

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

@@ -1,4 +1,5 @@
-import { SqlQueryOutput } from '@prisma/generator-helper';
+import { SqlQueryOutput } from '@prisma/generator';
+import { SchemaContext } from '@prisma/internals';
 import { EngineArgs } from '../types';
 export interface IntrospectSqlInput extends EngineArgs.SqlQueryInput {
     fileName: string;
@@ -14,4 +15,4 @@ export type IntrospectSqlResult = {
     ok: false;
     errors: IntrospectSqlError[];
 };
-export declare function introspectSql(schemaPath: string | undefined, queries: IntrospectSqlInput[]): Promise<IntrospectSqlResult>;
+export declare function introspectSql(schemaContext: SchemaContext, queries: IntrospectSqlInput[]): Promise<IntrospectSqlResult>;

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

@@ -0,0 +1,9 @@
+import type { MigrateTypes } from '@prisma/internals';
+/**
+ * Lists migrations present in the migrations directory, sorted lexicographically by name.
+ * Returns an empty array if the directory doesn't exist.
+ *
+ * @param migrationsDirectoryPath Absolute path to the migrations directory
+ * @returns Promise resolving to a sorted list of migrations
+ */
+export declare function listMigrations(migrationsDirectoryPath: string): Promise<MigrateTypes.MigrationList>;

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

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

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

@@ -1,7 +1,5 @@
-export declare function verifySeedConfigAndReturnMessage(schemaPath: string | null): Promise<string | undefined>;
 export declare function getSeedCommandFromPackageJson(cwd: string): Promise<string | null>;
 export declare function executeSeedCommand({ commandFromConfig, extraArgs, }: {
     commandFromConfig: string;
     extraArgs?: string;
 }): Promise<boolean>;
-export declare function legacyTsNodeScriptWarning(): Promise<undefined>;

package/dist/migrate/src/views/handleViewsIO.d.ts

@@ -5,7 +5,7 @@ export interface IntrospectionViewDefinition {
 }
 type HandleViewsIOParams = {
     views: IntrospectionViewDefinition[];
-    schemaPath: string;
+    viewsDirectoryPath: string;
 };
 /**
  * For any given view definitions, the CLI must either create or update the corresponding view definition files
@@ -13,5 +13,5 @@ type HandleViewsIOParams = {
  * If some other non ".sql" files or folders exist within the `views` directory, the CLI must preserve them.
  * In case of empty folders, these are deleted silently.
  */
-export declare function handleViewsIO({ views, schemaPath }: HandleViewsIOParams): Promise<void>;
+export declare function handleViewsIO({ views, viewsDirectoryPath }: HandleViewsIOParams): Promise<void>;
 export {};