@prisma/config 6.20.0-integration-merge-release-workflows.2 → 6.20.0-integration-feat-prisma-7-config.3

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-import { Schema } from 'effect';
-
 /**
  * An interface that exposes some basic information about the
  * adapter like its name and provider type.
@@ -87,6 +85,15 @@ declare type ConnectionInfo = {
     supportsRelationJoins: boolean;
 };
 
+export declare type Datasource = {
+    url: string;
+    /**
+     * @deprecated
+     */
+    directUrl?: string;
+    shadowDatabaseUrl?: string;
+};
+
 /**
  * This default config can be used as basis for unit and integration tests.
  */
@@ -119,34 +126,7 @@ declare type EnumsConfigShape = {
 
 export declare function env<Env extends Record<string, string | undefined>>(name: keyof Env & string): string;
 
-declare type Error_2 = MappedError & {
-    originalCode?: string;
-    originalMessage?: string;
-};
-
-declare type ErrorCapturingFunction<T> = T extends (...args: infer A) => Promise<infer R> ? (...args: A) => Promise<Result<ErrorCapturingInterface<R>>> : T extends (...args: infer A) => infer R ? (...args: A) => Result<ErrorCapturingInterface<R>> : T;
-
-declare type ErrorCapturingInterface<T> = {
-    [K in keyof T]: ErrorCapturingFunction<T[K]>;
-};
-
-declare interface ErrorCapturingSqlMigrationAwareDriverAdapterFactory extends ErrorCapturingInterface<SqlMigrationAwareDriverAdapterFactory> {
-    readonly errorRegistry: ErrorRegistry;
-}
-
-declare type ErrorRecord = {
-    error: unknown;
-};
-
-declare interface ErrorRegistry {
-    consumeError(id: number): ErrorRecord | undefined;
-}
-
 declare type ExperimentalConfig = {
-    /**
-     * Enable experimental adapter support.
-     */
-    adapter?: boolean;
     /**
      * Enable experimental Prisma Studio features.
      */
@@ -204,130 +184,6 @@ declare type LoadConfigFromFileInput = {
     configRoot?: string;
 };
 
-/**
- * User's Prisma configuration should live in `prisma.config.ts` instead of `package.json#prisma`.
- * See: https://pris.ly/prisma-config.
- *
- * This function returns `null` if no `package.json` is found, or if the `prisma` property is not defined therein.
- *
- * TODO: remove in Prisma 7.
- * @deprecated
- */
-export declare function loadConfigFromPackageJson(cwd?: string): Promise<{
-    config: PrismaConfigPackageJson;
-    loadedFromFile: string;
-} | null>;
-
-declare type MappedError = {
-    kind: 'GenericJs';
-    id: number;
-} | {
-    kind: 'UnsupportedNativeDataType';
-    type: string;
-} | {
-    kind: 'InvalidIsolationLevel';
-    level: string;
-} | {
-    kind: 'LengthMismatch';
-    column?: string;
-} | {
-    kind: 'UniqueConstraintViolation';
-    constraint?: {
-        fields: string[];
-    } | {
-        index: string;
-    } | {
-        foreignKey: {};
-    };
-} | {
-    kind: 'NullConstraintViolation';
-    constraint?: {
-        fields: string[];
-    } | {
-        index: string;
-    } | {
-        foreignKey: {};
-    };
-} | {
-    kind: 'ForeignKeyConstraintViolation';
-    constraint?: {
-        fields: string[];
-    } | {
-        index: string;
-    } | {
-        foreignKey: {};
-    };
-} | {
-    kind: 'DatabaseNotReachable';
-    host?: string;
-    port?: number;
-} | {
-    kind: 'DatabaseDoesNotExist';
-    db?: string;
-} | {
-    kind: 'DatabaseAlreadyExists';
-    db?: string;
-} | {
-    kind: 'DatabaseAccessDenied';
-    db?: string;
-} | {
-    kind: 'ConnectionClosed';
-} | {
-    kind: 'TlsConnectionError';
-    reason: string;
-} | {
-    kind: 'AuthenticationFailed';
-    user?: string;
-} | {
-    kind: 'TransactionWriteConflict';
-} | {
-    kind: 'TableDoesNotExist';
-    table?: string;
-} | {
-    kind: 'ColumnNotFound';
-    column?: string;
-} | {
-    kind: 'TooManyConnections';
-    cause: string;
-} | {
-    kind: 'ValueOutOfRange';
-    cause: string;
-} | {
-    kind: 'MissingFullTextSearchIndex';
-} | {
-    kind: 'SocketTimeout';
-} | {
-    kind: 'InconsistentColumnData';
-    cause: string;
-} | {
-    kind: 'TransactionAlreadyClosed';
-    cause: string;
-} | {
-    kind: 'postgres';
-    code: string;
-    severity: string;
-    message: string;
-    detail: string | undefined;
-    column: string | undefined;
-    hint: string | undefined;
-} | {
-    kind: 'mysql';
-    code: number;
-    message: string;
-    state: string;
-} | {
-    kind: 'sqlite';
-    /**
-     * Sqlite extended error code: https://www.sqlite.org/rescode.html
-     */
-    extendedCode: number;
-    message: string;
-} | {
-    kind: 'mssql';
-    code: number;
-    message: string;
-};
-
 declare type MigrationsConfigShape = {
     /**
      * The path to the directory where Prisma should store migration files, and look for them.
@@ -352,70 +208,11 @@ declare const PRISMA_CONFIG_INTERNAL_BRAND: unique symbol;
  * The configuration for the Prisma Development Kit, before it is passed to the `defineConfig` function.
  * Thanks to the branding, this type is opaque and cannot be constructed directly.
  */
-export declare type PrismaConfig = PrismaConfigUnconditional & SchemaEngineConfig;
-
-export declare class PrismaConfigEnvError extends Error {
-    constructor(name: string);
-}
-
-/**
- * The configuration for the Prisma Development Kit, after it has been parsed and processed
- * by the `defineConfig` function.
- * Thanks to the branding, this type is opaque and cannot be constructed directly.
- */
-export declare type PrismaConfigInternal = _PrismaConfigInternal & {
-    __brand: typeof PRISMA_CONFIG_INTERNAL_BRAND;
-};
-
-declare type _PrismaConfigInternal = Omit<PrismaConfig, 'engine' | 'datasource' | 'adapter'> & {
-    loadedFromFile: string | null;
+export declare type PrismaConfig = {
     /**
-     * The deprecated Prisma configuration from `package.json#prisma`.
-     * This is set to `null` if no `package.json#prisma` config was found.
-     * The configuration read from the Prisma config file (e.g., `prisma.config.ts`) takes precedence over
-     * this `package.json#prisma` config.
-     * @deprecated
+     * The datasource URL configuration for the database connection.
      */
-    deprecatedPackageJson: {
-        /**
-         * The Prisma configuration from `package.json#prisma`.
-         * @deprecated
-         */
-        config: PrismaConfigPackageJson;
-        /**
-         * The path from where the `package.json` config was loaded.
-         * @deprecated
-         */
-        loadedFromFile: string;
-    } | null;
-} & ({
-    engine: 'classic';
-    datasource: {
-        url: string;
-        shadowDatabaseUrl?: string;
-    };
-} | {
-    engine: 'js';
-    adapter: () => Promise<ErrorCapturingSqlMigrationAwareDriverAdapterFactory>;
-} | {
-    engine?: never;
-});
-
-/**
- * Example:
- * ```json
- * {
- *   "schema": "./prisma/schema.prisma",
- *   "seed": "tsx ./prisma/seed.ts"
- * }
- * ```
- */
-declare type PrismaConfigPackageJson = {
-    schema?: string;
-    seed?: string;
-};
-
-declare type PrismaConfigUnconditional = {
+    datasource?: Simplify<Datasource>;
     /**
      * Experimental feature gates. Each experimental feature must be explicitly enabled.
      */
@@ -450,6 +247,23 @@ declare type PrismaConfigUnconditional = {
     typedSql?: Simplify<TypedSqlConfigShape>;
 };
 
+export declare class PrismaConfigEnvError extends Error {
+    constructor(name: string);
+}
+
+/**
+ * The configuration for the Prisma Development Kit, after it has been parsed and processed
+ * by the `defineConfig` function.
+ * Thanks to the branding, this type is opaque and cannot be constructed directly.
+ */
+export declare type PrismaConfigInternal = _PrismaConfigInternal & {
+    __brand: typeof PRISMA_CONFIG_INTERNAL_BRAND;
+};
+
+declare type _PrismaConfigInternal = PrismaConfig & {
+    loadedFromFile: string | null;
+};
+
 declare type PrismaStudioConfigShape = {
     adapter: () => Promise<SqlMigrationAwareDriverAdapterFactory>;
 };
@@ -467,69 +281,10 @@ declare interface Queryable<Query, Result> extends AdapterInfo {
     executeRaw(params: Query): Promise<number>;
 }
 
-declare type Result<T> = {
-    map<U>(fn: (value: T) => U): Result<U>;
-    flatMap<U>(fn: (value: T) => Result<U>): Result<U>;
-} & ({
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly error: Error_2;
-});
-
-declare type SchemaEngineConfig = SchemaEngineConfigJs | SchemaEngineConfigClassic | SchemaEngineConfigAbsent;
-
-declare type SchemaEngineConfigAbsent = {
-    engine?: never;
-};
-
-declare type SchemaEngineConfigClassic = {
-    /**
-     * Uses the "old classic" Schema Engine binary
-     */
-    engine: 'classic';
-    /**
-     * The database connection configuration, which overwrites the `datasource` block's `url`-like attributes in the Prisma schema file.
-     */
-    datasource: SchemaEngineConfigClassicDatasource;
-};
-
-export declare type SchemaEngineConfigClassicDatasource = {
-    url: string;
-    directUrl?: string;
-    shadowDatabaseUrl?: string;
+export declare type SchemaEngineConfigInternal = {
+    datasource?: Datasource;
 };
 
-export declare type SchemaEngineConfigInternal = SchemaEngineConfigJsInternal | SchemaEngineConfigClassic | SchemaEngineConfigAbsent;
-
-declare type SchemaEngineConfigJs = {
-    /**
-     * Uses the new, unstable JavaScript based Schema Engine.
-     */
-    engine: 'js';
-    /**
-     * The function that instantiates the driver adapter to use for the JavaScript based Schema Engine.
-     */
-    adapter: () => Promise<SqlMigrationAwareDriverAdapterFactory>;
-};
-
-declare type SchemaEngineConfigJsInternal = {
-    /**
-     * Uses the new, unstable JavaScript based Schema Engine.
-     */
-    engine: 'js';
-    /**
-     * The function that instantiates the driver adapter to use for the JavaScript based Schema Engine.
-     */
-    adapter: () => Promise<ErrorCapturingSqlMigrationAwareDriverAdapterFactory>;
-};
-
-declare const SchemaEngineConfigJsInternal: Schema.Struct<{
-    engine: Schema.Literal<["js"]>;
-    adapter: Schema.declare<() => Promise<ErrorCapturingSqlMigrationAwareDriverAdapterFactory>, () => Promise<ErrorCapturingSqlMigrationAwareDriverAdapterFactory>, readonly [], never>;
-}>;
-
 /**
  * Simplifies the type signature of a type.
  * Re-exported from `effect/Types`.

package/dist/index.js

@@ -34,8 +34,7 @@ __export(index_exports, {
   defaultTestConfig: () => defaultTestConfig,
   defineConfig: () => defineConfig,
   env: () => env,
-  loadConfigFromFile: () => loadConfigFromFile,
-  loadConfigFromPackageJson: () => loadConfigFromPackageJson
+  loadConfigFromFile: () => loadConfigFromFile
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -226,129 +225,7 @@ function safeStringify(value, indent = 2) {
 }
 
 // ../driver-adapter-utils/dist/index.mjs
-function isDriverAdapterError(error) {
-  return error["name"] === "DriverAdapterError" && typeof error["cause"] === "object";
-}
-function ok(value) {
-  return {
-    ok: true,
-    value,
-    map(fn) {
-      return ok(fn(value));
-    },
-    flatMap(fn) {
-      return fn(value);
-    }
-  };
-}
-function err(error) {
-  return {
-    ok: false,
-    error,
-    map() {
-      return err(error);
-    },
-    flatMap() {
-      return err(error);
-    }
-  };
-}
 var debug = Debug("driver-adapter-utils");
-var ErrorRegistryInternal = class {
-  registeredErrors = [];
-  consumeError(id) {
-    return this.registeredErrors[id];
-  }
-  registerNewError(error) {
-    let i = 0;
-    while (this.registeredErrors[i] !== void 0) {
-      i++;
-    }
-    this.registeredErrors[i] = { error };
-    return i;
-  }
-};
-function copySymbolsFromSource(source, target) {
-  const symbols = Object.getOwnPropertySymbols(source);
-  const symbolObject = Object.fromEntries(symbols.map((symbol) => [symbol, true]));
-  Object.assign(target, symbolObject);
-}
-var bindMigrationAwareSqlAdapterFactory = (adapterFactory) => {
-  const errorRegistry = new ErrorRegistryInternal();
-  const boundFactory = {
-    adapterName: adapterFactory.adapterName,
-    provider: adapterFactory.provider,
-    errorRegistry,
-    connect: async (...args) => {
-      const ctx = await wrapAsync(errorRegistry, adapterFactory.connect.bind(adapterFactory))(...args);
-      return ctx.map((ctx2) => bindAdapter(ctx2, errorRegistry));
-    },
-    connectToShadowDb: async (...args) => {
-      const ctx = await wrapAsync(errorRegistry, adapterFactory.connectToShadowDb.bind(adapterFactory))(...args);
-      return ctx.map((ctx2) => bindAdapter(ctx2, errorRegistry));
-    }
-  };
-  copySymbolsFromSource(adapterFactory, boundFactory);
-  return boundFactory;
-};
-var bindAdapter = (adapter, errorRegistry = new ErrorRegistryInternal()) => {
-  const boundAdapter = {
-    adapterName: adapter.adapterName,
-    errorRegistry,
-    queryRaw: wrapAsync(errorRegistry, adapter.queryRaw.bind(adapter)),
-    executeRaw: wrapAsync(errorRegistry, adapter.executeRaw.bind(adapter)),
-    executeScript: wrapAsync(errorRegistry, adapter.executeScript.bind(adapter)),
-    dispose: wrapAsync(errorRegistry, adapter.dispose.bind(adapter)),
-    provider: adapter.provider,
-    startTransaction: async (...args) => {
-      const ctx = await wrapAsync(errorRegistry, adapter.startTransaction.bind(adapter))(...args);
-      return ctx.map((ctx2) => bindTransaction(errorRegistry, ctx2));
-    }
-  };
-  if (adapter.getConnectionInfo) {
-    boundAdapter.getConnectionInfo = wrapSync(errorRegistry, adapter.getConnectionInfo.bind(adapter));
-  }
-  return boundAdapter;
-};
-var bindTransaction = (errorRegistry, transaction) => {
-  return {
-    adapterName: transaction.adapterName,
-    provider: transaction.provider,
-    options: transaction.options,
-    queryRaw: wrapAsync(errorRegistry, transaction.queryRaw.bind(transaction)),
-    executeRaw: wrapAsync(errorRegistry, transaction.executeRaw.bind(transaction)),
-    commit: wrapAsync(errorRegistry, transaction.commit.bind(transaction)),
-    rollback: wrapAsync(errorRegistry, transaction.rollback.bind(transaction))
-  };
-};
-function wrapAsync(registry, fn) {
-  return async (...args) => {
-    try {
-      return ok(await fn(...args));
-    } catch (error) {
-      debug("[error@wrapAsync]", error);
-      if (isDriverAdapterError(error)) {
-        return err(error.cause);
-      }
-      const id = registry.registerNewError(error);
-      return err({ kind: "GenericJs", id });
-    }
-  };
-}
-function wrapSync(registry, fn) {
-  return (...args) => {
-    try {
-      return ok(fn(...args));
-    } catch (error) {
-      debug("[error@wrapSync]", error);
-      if (isDriverAdapterError(error)) {
-        return err(error.cause);
-      }
-      const id = registry.registerNewError(error);
-      return err({ kind: "GenericJs", id });
-    }
-  };
-}
 var mockAdapterErrors = {
   queryRaw: new Error("Not implemented: queryRaw"),
   executeRaw: new Error("Not implemented: executeRaw"),
@@ -358,7 +235,7 @@ var mockAdapterErrors = {
 };
 
 // src/PrismaConfig.ts
-var import_effect3 = require("effect");
+var import_effect2 = require("effect");
 var import_Function = require("effect/Function");
 
 // src/defineConfig.ts
@@ -368,18 +245,15 @@ var import_effect = require("effect");
 function defaultConfig() {
   return makePrismaConfigInternal({
     loadedFromFile: null,
-    deprecatedPackageJson: null
+    datasource: {
+      url: "<default_datasource_url>"
+    }
   });
 }
 
 // src/defineConfig.ts
 function validateExperimentalFeatures(config) {
   const experimental = config.experimental || {};
-  if (config.engine === "js" && !experimental.adapter) {
-    return import_effect.Either.left(
-      new Error('The `engine === "js"` configuration requires `experimental.adapter` to be set to `true`.')
-    );
-  }
   if (config.studio && !experimental.studio) {
     return import_effect.Either.left(new Error("The `studio` configuration requires `experimental.studio` to be set to `true`."));
   }
@@ -412,7 +286,7 @@ function defineConfig(configInput) {
   debug2("[default]: %o", config);
   defineExperimentalConfig(config, configInput);
   defineSchemaConfig(config, configInput);
-  defineEngineConfig(config, configInput);
+  defineDatasource(config, configInput);
   defineStudioConfig(config, configInput);
   defineMigrationsConfig(config, configInput);
   defineTablesConfig(config, configInput);
@@ -485,25 +359,10 @@ function defineStudioConfig(config, configInput) {
   };
   debug2("[config.studio]: %o", config.studio);
 }
-function defineEngineConfig(config, configInput) {
-  if (configInput.engine === void 0) {
-    return;
-  } else if (configInput.engine === "js") {
-    const { engine, adapter: getAdapterFactory } = configInput;
-    const adapter = async () => {
-      const adapterFactory = await getAdapterFactory();
-      debug2("[config.adapter]: %o", adapterFactory.adapterName);
-      return bindMigrationAwareSqlAdapterFactory(adapterFactory);
-    };
-    Object.assign(config, { engine, adapter });
-    debug2("[config.engine]: %o", engine);
-    debug2("[config.adapter]: %o", adapter);
-  } else if (configInput.engine === "classic") {
-    const { engine, datasource } = configInput;
-    Object.assign(config, { engine, datasource });
-    debug2("[config.engine]: %o", engine);
-    debug2("[config.datasource]: %o", datasource);
-  }
+function defineDatasource(config, configInput) {
+  const { datasource } = configInput;
+  Object.assign(config, { datasource });
+  debug2("[config.datasource]: %o", datasource);
 }
 function defineExtensionsConfig(config, configInput) {
   if (!configInput["extensions"]) {
@@ -513,133 +372,73 @@ function defineExtensionsConfig(config, configInput) {
   debug2("[config.extensions]: %o", config["extensions"]);
 }
 
-// src/loadConfigFromPackageJson.ts
-var import_promises = require("node:fs/promises");
-var import_node_process = __toESM(require("node:process"));
-var import_effect2 = require("effect");
-var import_package = require("empathic/package");
-var PrismaConfigPackageJsonShape = import_effect2.Schema.Struct({
-  schema: import_effect2.Schema.optional(import_effect2.Schema.String),
-  seed: import_effect2.Schema.optional(import_effect2.Schema.NonEmptyString)
-});
-async function loadConfigFromPackageJson(cwd = import_node_process.default.cwd()) {
-  const pkgPath = (0, import_package.up)({ cwd });
-  if (pkgPath === void 0) {
-    return null;
-  }
-  const pkgJson = await (0, import_promises.readFile)(pkgPath, { encoding: "utf-8" }).then((p) => JSON.parse(p));
-  const deprecatedConfig = pkgJson["prisma"];
-  if (deprecatedConfig === void 0) {
-    return null;
-  }
-  if (Object.keys(deprecatedConfig).length === 1 && deprecatedConfig["prismaCommit"] !== void 0) {
-    return null;
-  }
-  return {
-    config: deprecatedConfig,
-    loadedFromFile: pkgPath
-  };
-}
-
 // src/PrismaConfig.ts
 var debug3 = Debug("prisma:config:PrismaConfig");
-var SqlMigrationAwareDriverAdapterFactoryShape = import_effect3.Schema.declare(
+var SqlMigrationAwareDriverAdapterFactoryShape = import_effect2.Schema.declare(
   (input) => {
     return typeof input === "function";
   },
   {
     identifier: "SqlMigrationAwareDriverAdapterFactory",
-    encode: import_effect3.identity,
-    decode: import_effect3.identity
+    encode: import_effect2.identity,
+    decode: import_effect2.identity
   }
 );
-var ErrorCapturingSqlMigrationAwareDriverAdapterFactoryShape = import_effect3.Schema.declare(
-  (input) => {
-    return typeof input === "function";
-  },
-  {
-    identifier: "ErrorCapturingSqlMigrationAwareDriverAdapterFactory",
-    encode: import_effect3.identity,
-    decode: import_effect3.identity
-  }
-);
-var SchemaEngineConfigClassicShape = import_effect3.Schema.Struct({
-  engine: import_effect3.Schema.Literal("classic"),
-  datasource: import_effect3.Schema.Struct({
-    url: import_effect3.Schema.String,
-    directUrl: import_effect3.Schema.optional(import_effect3.Schema.String),
-    shadowDatabaseUrl: import_effect3.Schema.optional(import_effect3.Schema.String)
-  })
-});
-var SchemaEngineConfigJsShape = import_effect3.Schema.Struct({
-  engine: import_effect3.Schema.Literal("js"),
-  adapter: SqlMigrationAwareDriverAdapterFactoryShape
-});
-var SchemaEngineConfigAbsentShape = import_effect3.Schema.Struct({
-  engine: import_effect3.Schema.optional(import_effect3.Schema.Never)
-});
-var SchemaEngineConfigShape = import_effect3.Schema.Union(
-  SchemaEngineConfigClassicShape,
-  SchemaEngineConfigJsShape,
-  SchemaEngineConfigAbsentShape
-);
-var SchemaEngineConfigJsInternal = import_effect3.Schema.Struct({
-  engine: import_effect3.Schema.Literal("js"),
-  adapter: ErrorCapturingSqlMigrationAwareDriverAdapterFactoryShape
+var DatasourceShape = import_effect2.Schema.Struct({
+  url: import_effect2.Schema.String,
+  /**
+   * @deprecated
+   */
+  directUrl: import_effect2.Schema.optional(import_effect2.Schema.String),
+  shadowDatabaseUrl: import_effect2.Schema.optional(import_effect2.Schema.String)
 });
-var SchemaEngineConfigInternal = import_effect3.Schema.Union(
-  SchemaEngineConfigClassicShape,
-  SchemaEngineConfigJsInternal,
-  SchemaEngineConfigAbsentShape
-);
-var ExperimentalConfigShape = import_effect3.Schema.Struct({
-  adapter: import_effect3.Schema.optional(import_effect3.Schema.Boolean),
-  studio: import_effect3.Schema.optional(import_effect3.Schema.Boolean),
-  externalTables: import_effect3.Schema.optional(import_effect3.Schema.Boolean),
-  extensions: import_effect3.Schema.optional(import_effect3.Schema.Boolean)
+var ExperimentalConfigShape = import_effect2.Schema.Struct({
+  studio: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
+  externalTables: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
+  extensions: import_effect2.Schema.optional(import_effect2.Schema.Boolean)
 });
 if (false) {
   __testExperimentalConfigShapeValueA;
   __testExperimentalConfigShapeValueB;
 }
-var MigrationsConfigShape = import_effect3.Schema.Struct({
-  path: import_effect3.Schema.optional(import_effect3.Schema.String),
-  initShadowDb: import_effect3.Schema.optional(import_effect3.Schema.String),
-  seed: import_effect3.Schema.optional(import_effect3.Schema.NonEmptyString)
+var MigrationsConfigShape = import_effect2.Schema.Struct({
+  path: import_effect2.Schema.optional(import_effect2.Schema.String),
+  initShadowDb: import_effect2.Schema.optional(import_effect2.Schema.String),
+  seed: import_effect2.Schema.optional(import_effect2.Schema.NonEmptyString)
 });
 if (false) {
   __testMigrationsConfigShapeValueA;
   __testMigrationsConfigShapeValueB;
 }
-var TablesConfigShape = import_effect3.Schema.Struct({
-  external: import_effect3.Schema.optional(import_effect3.Schema.mutable(import_effect3.Schema.Array(import_effect3.Schema.String)))
+var TablesConfigShape = import_effect2.Schema.Struct({
+  external: import_effect2.Schema.optional(import_effect2.Schema.mutable(import_effect2.Schema.Array(import_effect2.Schema.String)))
 });
 if (false) {
   __testTablesConfigShapeValueA;
   __testTablesConfigShapeValueB;
 }
-var EnumsConfigShape = import_effect3.Schema.Struct({
-  external: import_effect3.Schema.optional(import_effect3.Schema.mutable(import_effect3.Schema.Array(import_effect3.Schema.String)))
+var EnumsConfigShape = import_effect2.Schema.Struct({
+  external: import_effect2.Schema.optional(import_effect2.Schema.mutable(import_effect2.Schema.Array(import_effect2.Schema.String)))
 });
 if (false) {
   __testEnumsConfigShapeValueA;
   __testEnumsConfigShapeValueB;
 }
-var ViewsConfigShape = import_effect3.Schema.Struct({
-  path: import_effect3.Schema.optional(import_effect3.Schema.String)
+var ViewsConfigShape = import_effect2.Schema.Struct({
+  path: import_effect2.Schema.optional(import_effect2.Schema.String)
 });
 if (false) {
   __testViewsConfigShapeValueA;
   __testViewsConfigShapeValueB;
 }
-var TypedSqlConfigShape = import_effect3.Schema.Struct({
-  path: import_effect3.Schema.optional(import_effect3.Schema.String)
+var TypedSqlConfigShape = import_effect2.Schema.Struct({
+  path: import_effect2.Schema.optional(import_effect2.Schema.String)
 });
 if (false) {
   __testTypedSqlConfigShapeValueA;
   __testTypedSqlConfigShapeValueB;
 }
-var PrismaStudioConfigShape = import_effect3.Schema.Struct({
+var PrismaStudioConfigShape = import_effect2.Schema.Struct({
   /**
    * Instantiates the Prisma driver adapter to use for Prisma Studio.
    */
@@ -653,80 +452,65 @@ if (false) {
   __testPrismaConfig;
   __testPrismaConfigInternal;
 }
-var PrismaConfigUnconditionalShape = import_effect3.Schema.Struct({
-  experimental: import_effect3.Schema.optional(ExperimentalConfigShape),
-  schema: import_effect3.Schema.optional(import_effect3.Schema.String),
-  studio: import_effect3.Schema.optional(PrismaStudioConfigShape),
-  migrations: import_effect3.Schema.optional(MigrationsConfigShape),
-  tables: import_effect3.Schema.optional(TablesConfigShape),
-  enums: import_effect3.Schema.optional(EnumsConfigShape),
-  views: import_effect3.Schema.optional(ViewsConfigShape),
-  typedSql: import_effect3.Schema.optional(TypedSqlConfigShape),
-  extensions: import_effect3.Schema.optional(import_effect3.Schema.Any)
+var PrismaConfigShape = import_effect2.Schema.Struct({
+  // @aqrln: datasource should be mandatory once we close https://linear.app/prisma-company/issue/TML-1545/remove-url-datasource-attribute-from-psl
+  datasource: import_effect2.Schema.optional(DatasourceShape),
+  experimental: import_effect2.Schema.optional(ExperimentalConfigShape),
+  schema: import_effect2.Schema.optional(import_effect2.Schema.String),
+  studio: import_effect2.Schema.optional(PrismaStudioConfigShape),
+  migrations: import_effect2.Schema.optional(MigrationsConfigShape),
+  tables: import_effect2.Schema.optional(TablesConfigShape),
+  enums: import_effect2.Schema.optional(EnumsConfigShape),
+  views: import_effect2.Schema.optional(ViewsConfigShape),
+  typedSql: import_effect2.Schema.optional(TypedSqlConfigShape),
+  extensions: import_effect2.Schema.optional(import_effect2.Schema.Any)
 });
-var PrismaConfigShape = import_effect3.Schema.extend(SchemaEngineConfigShape, PrismaConfigUnconditionalShape);
 if (false) {
   __testPrismaConfigValueA;
   __testPrismaConfigValueB;
 }
 function validateExperimentalFeatures2(config) {
   const experimental = config.experimental || {};
-  if (config.engine === "js" && !experimental.adapter) {
-    return import_effect3.Either.left(
-      new Error("The `engine === 'js'` configuration requires `experimental.adapter` to be set to `true`.")
-    );
-  }
   if (config.studio && !experimental.studio) {
-    return import_effect3.Either.left(new Error("The `studio` configuration requires `experimental.studio` to be set to `true`."));
+    return import_effect2.Either.left(new Error("The `studio` configuration requires `experimental.studio` to be set to `true`."));
   }
   if (config.tables?.external && !experimental.externalTables) {
-    return import_effect3.Either.left(
+    return import_effect2.Either.left(
       new Error("The `tables.external` configuration requires `experimental.externalTables` to be set to `true`.")
     );
   }
   if (config.enums?.external && !experimental.externalTables) {
-    return import_effect3.Either.left(
+    return import_effect2.Either.left(
       new Error("The `enums.external` configuration requires `experimental.externalTables` to be set to `true`.")
     );
   }
   if (config.migrations?.initShadowDb && !experimental.externalTables) {
-    return import_effect3.Either.left(
+    return import_effect2.Either.left(
       new Error(
         "The `migrations.initShadowDb` configuration requires `experimental.externalTables` to be set to `true`."
       )
     );
   }
   if (config["extensions"] && !experimental.extensions) {
-    return import_effect3.Either.left(
+    return import_effect2.Either.left(
       new Error("The `extensions` configuration requires `experimental.extensions` to be set to `true`.")
     );
   }
-  return import_effect3.Either.right(config);
+  return import_effect2.Either.right(config);
 }
 function parsePrismaConfigShape(input) {
   return (0, import_Function.pipe)(
-    import_effect3.Schema.decodeUnknownEither(PrismaConfigShape, {})(input, {
+    import_effect2.Schema.decodeUnknownEither(PrismaConfigShape, {})(input, {
       onExcessProperty: "error"
     }),
-    import_effect3.Either.flatMap(validateExperimentalFeatures2)
+    import_effect2.Either.flatMap(validateExperimentalFeatures2)
   );
 }
 var PRISMA_CONFIG_INTERNAL_BRAND = Symbol.for("PrismaConfigInternal");
-var PrismaConfigInternalShape = import_effect3.Schema.extend(
-  PrismaConfigUnconditionalShape,
-  import_effect3.Schema.extend(
-    SchemaEngineConfigInternal,
-    import_effect3.Schema.Struct({
-      loadedFromFile: import_effect3.Schema.NullOr(import_effect3.Schema.String),
-      deprecatedPackageJson: import_effect3.Schema.NullOr(
-        import_effect3.Schema.Struct({
-          config: PrismaConfigPackageJsonShape,
-          loadedFromFile: import_effect3.Schema.String
-        })
-      )
-    })
-  )
-);
+var PrismaConfigInternalShape = import_effect2.Schema.Struct({
+  ...PrismaConfigShape.fields,
+  loadedFromFile: import_effect2.Schema.NullOr(import_effect2.Schema.String)
+});
 function brandPrismaConfigInternal(config) {
   Object.defineProperty(config, "__brand", {
     value: PRISMA_CONFIG_INTERNAL_BRAND,
@@ -740,10 +524,10 @@ function parsePrismaConfigInternalShape(input) {
   debug3("Parsing PrismaConfigInternal: %o", input);
   if (typeof input === "object" && input !== null && input["__brand"] === PRISMA_CONFIG_INTERNAL_BRAND) {
     debug3("Short-circuit: input is already a PrismaConfigInternal object");
-    return import_effect3.Either.right(input);
+    return import_effect2.Either.right(input);
   }
   return (0, import_Function.pipe)(
-    import_effect3.Schema.decodeUnknownEither(PrismaConfigInternalShape, {})(input, {
+    import_effect2.Schema.decodeUnknownEither(PrismaConfigInternalShape, {})(input, {
       onExcessProperty: "error"
     }),
     // Brand the output type to make `PrismaConfigInternal` opaque, without exposing the `Effect/Brand` type
@@ -752,24 +536,24 @@ function parsePrismaConfigInternalShape(input) {
     // - https://github.com/microsoft/rushstack/issues/1308
     // - https://github.com/microsoft/rushstack/issues/4034
     // - https://github.com/microsoft/TypeScript/issues/58914
-    import_effect3.Either.map(brandPrismaConfigInternal)
+    import_effect2.Either.map(brandPrismaConfigInternal)
   );
 }
 function makePrismaConfigInternal(makeArgs) {
-  return brandPrismaConfigInternal(makeArgs);
+  return (0, import_Function.pipe)(PrismaConfigInternalShape.make(makeArgs), brandPrismaConfigInternal);
 }
 function parseDefaultExport(defaultExport) {
   const parseResultEither = (0, import_Function.pipe)(
     // If the given config conforms to the `PrismaConfig` shape, feed it to `defineConfig`.
     parsePrismaConfigShape(defaultExport),
-    import_effect3.Either.map((config) => {
+    import_effect2.Either.map((config) => {
       debug3("Parsed `PrismaConfig` shape: %o", config);
       return defineConfig(config);
     }),
     // Otherwise, try to parse it as a `PrismaConfigInternal` shape.
-    import_effect3.Either.orElse(() => parsePrismaConfigInternalShape(defaultExport))
+    import_effect2.Either.orElse(() => parsePrismaConfigInternalShape(defaultExport))
   );
-  if (import_effect3.Either.isLeft(parseResultEither)) {
+  if (import_effect2.Either.isLeft(parseResultEither)) {
     throw parseResultEither.left;
   }
   return parseResultEither.right;
@@ -779,7 +563,9 @@ function parseDefaultExport(defaultExport) {
 function defaultTestConfig() {
   return makePrismaConfigInternal({
     loadedFromFile: null,
-    deprecatedPackageJson: null
+    datasource: {
+      url: "<default_datasource_url>"
+    }
   });
 }
 
@@ -800,27 +586,16 @@ function env(name) {
 
 // src/loadConfigFromFile.ts
 var import_node_path = __toESM(require("node:path"));
-var import_node_process2 = __toESM(require("node:process"));
+var import_node_process = __toESM(require("node:process"));
 var debug4 = Debug("prisma:config:loadConfigFromFile");
 var SUPPORTED_EXTENSIONS = [".js", ".ts", ".mjs", ".cjs", ".mts", ".cts"];
 async function loadConfigFromFile({
   configFile,
-  configRoot = import_node_process2.default.cwd()
+  configRoot = import_node_process.default.cwd()
 }) {
   const start = performance.now();
   const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
   const diagnostics = [];
-  const deprecatedPrismaConfigFromJson = await loadConfigFromPackageJson(configRoot);
-  if (deprecatedPrismaConfigFromJson) {
-    diagnostics.push({
-      _tag: "warn",
-      value: ({ warn, link }) => () => warn(
-        `The configuration property \`package.json#prisma\` is deprecated and will be removed in Prisma 7. Please migrate to a Prisma config file (e.g., \`prisma.config.ts\`).
-For more information, see: ${link("https://pris.ly/prisma-config")}
-`
-      )
-    });
-  }
   try {
     const { configModule, resolvedPath, error } = await loadConfigTsOrJs(configRoot, configFile);
     if (error) {
@@ -855,20 +630,6 @@ For more information, see: ${link("https://pris.ly/prisma-config")}
 `))
     });
     const prismaConfig = transformPathsInConfigToAbsolute(parsedConfig, resolvedPath);
-    if (deprecatedPrismaConfigFromJson) {
-      diagnostics.push({
-        _tag: "warn",
-        value: ({ warn, link }) => () => warn(`The Prisma config file in ${import_node_path.default.relative(
-          configRoot,
-          resolvedPath
-        )} overrides the deprecated \`package.json#prisma\` property in ${import_node_path.default.relative(
-          configRoot,
-          deprecatedPrismaConfigFromJson.loadedFromFile
-        )}.
-  For more information, see: ${link("https://pris.ly/prisma-config")}
-`)
-      });
-    }
     return {
       config: {
         ...prismaConfig,
@@ -995,6 +756,5 @@ function transformPathsInConfigToAbsolute(prismaConfig, resolvedPath) {
   defaultTestConfig,
   defineConfig,
   env,
-  loadConfigFromFile,
-  loadConfigFromPackageJson
+  loadConfigFromFile
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/config",
-  "version": "6.20.0-integration-merge-release-workflows.2",
+  "version": "6.20.0-integration-feat-prisma-7-config.3",
   "description": "Internal package used to define and read Prisma configuration files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,9 +18,10 @@
     "empathic": "2.0.0"
   },
   "devDependencies": {
+    "dotenv": "17.2.3",
     "vitest": "3.2.4",
-    "@prisma/driver-adapter-utils": "6.20.0-integration-merge-release-workflows.2",
-    "@prisma/get-platform": "6.20.0-integration-merge-release-workflows.2"
+    "@prisma/driver-adapter-utils": "6.20.0-integration-feat-prisma-7-config.3",
+    "@prisma/get-platform": "6.20.0-integration-feat-prisma-7-config.3"
   },
   "files": [
     "dist"