@prisma/config 7.2.0 → 7.3.0-integration-prisma6-fix-cloudflare-engine.1

package/dist/index.d.ts

@@ -1,3 +1,61 @@
+import { Schema } from 'effect';
+
+/**
+ * An interface that exposes some basic information about the
+ * adapter like its name and provider type.
+ */
+declare interface AdapterInfo {
+    readonly provider: Provider;
+    readonly adapterName: (typeof officialPrismaAdapters)[number] | (string & {});
+}
+
+declare type ArgScalarType = 'string' | 'int' | 'bigint' | 'float' | 'decimal' | 'boolean' | 'enum' | 'uuid' | 'json' | 'datetime' | 'bytes' | 'unknown';
+
+declare type ArgType = {
+    scalarType: ArgScalarType;
+    dbType?: string;
+    arity: Arity;
+};
+
+declare type Arity = 'scalar' | 'list';
+
+declare type ColumnType = (typeof ColumnTypeEnum)[keyof typeof ColumnTypeEnum];
+
+declare const ColumnTypeEnum: {
+    readonly Int32: 0;
+    readonly Int64: 1;
+    readonly Float: 2;
+    readonly Double: 3;
+    readonly Numeric: 4;
+    readonly Boolean: 5;
+    readonly Character: 6;
+    readonly Text: 7;
+    readonly Date: 8;
+    readonly Time: 9;
+    readonly DateTime: 10;
+    readonly Json: 11;
+    readonly Enum: 12;
+    readonly Bytes: 13;
+    readonly Set: 14;
+    readonly Uuid: 15;
+    readonly Int32Array: 64;
+    readonly Int64Array: 65;
+    readonly FloatArray: 66;
+    readonly DoubleArray: 67;
+    readonly NumericArray: 68;
+    readonly BooleanArray: 69;
+    readonly CharacterArray: 70;
+    readonly TextArray: 71;
+    readonly DateArray: 72;
+    readonly TimeArray: 73;
+    readonly DateTimeArray: 74;
+    readonly JsonArray: 75;
+    readonly EnumArray: 76;
+    readonly BytesArray: 77;
+    readonly UuidArray: 78;
+    readonly UnknownNumber: 128;
+};
+
 export declare type ConfigDiagnostic = {
     _tag: 'log';
     value: (formatters: InjectFormatters) => () => void;
@@ -23,9 +81,10 @@ export declare type ConfigFromFile = {
     diagnostics: ConfigDiagnostic[];
 };
 
-export declare type Datasource = {
-    url?: string;
-    shadowDatabaseUrl?: string;
+declare type ConnectionInfo = {
+    schemaName?: string;
+    maxBindValues?: number;
+    supportsRelationJoins: boolean;
 };
 
 /**
@@ -38,6 +97,17 @@ export declare function defaultTestConfig(): PrismaConfigInternal;
  */
 export declare function defineConfig(configInput: PrismaConfig): PrismaConfigInternal;
 
+/**
+ * A generic driver adapter factory that allows the user to instantiate a
+ * driver adapter. The query and result types are specific to the adapter.
+ */
+declare interface DriverAdapterFactory<Query, Result> extends AdapterInfo {
+    /**
+     * Instantiate a driver adapter.
+     */
+    connect(): Promise<Queryable<Query, Result>>;
+}
+
 declare type EnumsConfigShape = {
     /**
      * List of enums that are externally managed.
@@ -47,15 +117,40 @@ declare type EnumsConfigShape = {
     external?: string[];
 };
 
-export declare function env(name: string): string;
+export declare function env<Env extends Record<string, string | undefined>>(name: keyof Env & string): string;
+
+declare type Error_2 = MappedError & {
+    originalCode?: string;
+    originalMessage?: string;
+};
 
-export declare function env<Env>(name: EnvKey<Env> & string): 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 EnvKey<Env> = keyof {
-    [K in keyof Env as Env[K] extends string | undefined ? K : never]: Env[K];
+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.
+     */
+    studio?: boolean;
     /**
      * Enable experimental external tables support.
      */
@@ -73,6 +168,8 @@ export declare type InjectFormatters = {
     link: (data: string) => string;
 };
 
+declare type IsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SNAPSHOT' | 'SERIALIZABLE';
+
 /**
  * Load a Prisma config file from the given directory.
  * This function may fail, but it will never throw.
@@ -107,6 +204,130 @@ 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.
@@ -123,25 +344,90 @@ declare type MigrationsConfigShape = {
     seed?: string;
 };
 
+declare const officialPrismaAdapters: readonly ["@prisma/adapter-planetscale", "@prisma/adapter-neon", "@prisma/adapter-libsql", "@prisma/adapter-better-sqlite3", "@prisma/adapter-d1", "@prisma/adapter-pg", "@prisma/adapter-mssql", "@prisma/adapter-mariadb"];
+
 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 = {
+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;
     /**
-     * Experimental feature gates. Each experimental feature must be explicitly enabled.
+     * 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
      */
-    experimental?: Simplify<ExperimentalConfig>;
+    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 = {
     /**
-     * The datasource configuration. Optional for most cases, but required for migration / introspection commands.
+     * Experimental feature gates. Each experimental feature must be explicitly enabled.
      */
-    datasource?: Simplify<Datasource>;
+    experimental?: Simplify<ExperimentalConfig>;
     /**
      * The path to the schema file, or path to a folder that shall be recursively searched for *.prisma files.
      */
     schema?: string;
+    /**
+     * The configuration for Prisma Studio.
+     */
+    studio?: Simplify<PrismaStudioConfigShape>;
     /**
      * Configuration for Prisma migrations.
      */
@@ -164,27 +450,86 @@ export declare type PrismaConfig = {
     typedSql?: Simplify<TypedSqlConfigShape>;
 };
 
-export declare class PrismaConfigEnvError extends Error {
-    constructor(name: string);
+declare type PrismaStudioConfigShape = {
+    adapter: () => Promise<SqlMigrationAwareDriverAdapterFactory>;
+};
+
+declare type Provider = 'mysql' | 'postgres' | 'sqlite' | 'sqlserver';
+
+declare interface Queryable<Query, Result> extends AdapterInfo {
+    /**
+     * Execute a query and return its result.
+     */
+    queryRaw(params: Query): Promise<Result>;
+    /**
+     * Execute a query and return the number of affected rows.
+     */
+    executeRaw(params: Query): Promise<number>;
 }
 
-/**
- * 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 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 _PrismaConfigInternal = PrismaConfig & {
-    loadedFromFile: string | null;
+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 SchemaEngineConfigInternal = {
-    datasource?: Datasource;
+export declare type SchemaEngineConfigClassicDatasource = {
+    url: string;
+    directUrl?: string;
+    shadowDatabaseUrl?: string;
 };
 
+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`.
@@ -198,6 +543,68 @@ declare type Simplify<A> = {
     [K in keyof A]: A[K];
 } extends infer B ? B : never;
 
+declare interface SqlDriverAdapter extends SqlQueryable {
+    /**
+     * Execute multiple SQL statements separated by semicolon.
+     */
+    executeScript(script: string): Promise<void>;
+    /**
+     * Start new transaction.
+     */
+    startTransaction(isolationLevel?: IsolationLevel): Promise<Transaction>;
+    /**
+     * Optional method that returns extra connection info
+     */
+    getConnectionInfo?(): ConnectionInfo;
+    /**
+     * Dispose of the connection and release any resources.
+     */
+    dispose(): Promise<void>;
+}
+
+declare interface SqlDriverAdapterFactory extends DriverAdapterFactory<SqlQuery, SqlResultSet> {
+    connect(): Promise<SqlDriverAdapter>;
+}
+
+/**
+ * An SQL migration adapter that is aware of the notion of a shadow database
+ * and can create a connection to it.
+ */
+declare interface SqlMigrationAwareDriverAdapterFactory extends SqlDriverAdapterFactory {
+    connectToShadowDb(): Promise<SqlDriverAdapter>;
+}
+
+declare type SqlQuery = {
+    sql: string;
+    args: Array<unknown>;
+    argTypes: Array<ArgType>;
+};
+
+declare interface SqlQueryable extends Queryable<SqlQuery, SqlResultSet> {
+}
+
+declare interface SqlResultSet {
+    /**
+     * List of column types appearing in a database query, in the same order as `columnNames`.
+     * They are used within the Query Engine to convert values from JS to Quaint values.
+     */
+    columnTypes: Array<ColumnType>;
+    /**
+     * List of column names appearing in a database query, in the same order as `columnTypes`.
+     */
+    columnNames: Array<string>;
+    /**
+     * List of rows retrieved from a database query.
+     * Each row is a list of values, whose length matches `columnNames` and `columnTypes`.
+     */
+    rows: Array<Array<unknown>>;
+    /**
+     * The last ID of an `INSERT` statement, if any.
+     * This is required for `AUTO_INCREMENT` columns in databases based on MySQL and SQLite.
+     */
+    lastInsertId?: string;
+}
+
 declare type TablesConfigShape = {
     /**
      * List of tables that are externally managed.
@@ -207,6 +614,25 @@ declare type TablesConfigShape = {
     external?: string[];
 };
 
+declare interface Transaction extends AdapterInfo, SqlQueryable {
+    /**
+     * Transaction options.
+     */
+    readonly options: TransactionOptions;
+    /**
+     * Commit the transaction.
+     */
+    commit(): Promise<void>;
+    /**
+     * Roll back the transaction.
+     */
+    rollback(): Promise<void>;
+}
+
+declare type TransactionOptions = {
+    usePhantomQuery: boolean;
+};
+
 declare type TypedSqlConfigShape = {
     /**
      * The path to the directory where Prisma should look for the `typedSql` queries, where *.sql files will be loaded.

package/dist/index.js

@@ -34,7 +34,8 @@ __export(index_exports, {
   defaultTestConfig: () => defaultTestConfig,
   defineConfig: () => defineConfig,
   env: () => env,
-  loadConfigFromFile: () => loadConfigFromFile
+  loadConfigFromFile: () => loadConfigFromFile,
+  loadConfigFromPackageJson: () => loadConfigFromPackageJson
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -224,8 +225,140 @@ 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"),
+  startTransaction: new Error("Not implemented: startTransaction"),
+  executeScript: new Error("Not implemented: executeScript"),
+  dispose: new Error("Not implemented: dispose")
+};
+
 // src/PrismaConfig.ts
-var import_effect2 = require("effect");
+var import_effect3 = require("effect");
 var import_Function = require("effect/Function");
 
 // src/defineConfig.ts
@@ -234,13 +367,22 @@ var import_effect = require("effect");
 // src/defaultConfig.ts
 function defaultConfig() {
   return makePrismaConfigInternal({
-    loadedFromFile: null
+    loadedFromFile: null,
+    deprecatedPackageJson: null
   });
 }
 
 // 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`."));
+  }
   if (config.tables?.external && !experimental.externalTables) {
     return import_effect.Either.left(
       new Error("The `tables.external` configuration requires `experimental.externalTables` to be set to `true`.")
@@ -260,17 +402,18 @@ function validateExperimentalFeatures(config) {
   }
   return import_effect.Either.right(config);
 }
-var debug = Debug("prisma:config:defineConfig");
+var debug2 = Debug("prisma:config:defineConfig");
 function defineConfig(configInput) {
   const validationResult = validateExperimentalFeatures(configInput);
   if (validationResult._tag === "Left") {
     throw validationResult.left;
   }
   const config = defaultConfig();
-  debug("[default]: %o", config);
+  debug2("[default]: %o", config);
   defineExperimentalConfig(config, configInput);
   defineSchemaConfig(config, configInput);
-  defineDatasource(config, configInput);
+  defineEngineConfig(config, configInput);
+  defineStudioConfig(config, configInput);
   defineMigrationsConfig(config, configInput);
   defineTablesConfig(config, configInput);
   defineEnumsConfig(config, configInput);
@@ -284,172 +427,306 @@ function defineExperimentalConfig(config, configInput) {
     return;
   }
   config.experimental = configInput.experimental;
-  debug("[config.experimental]: %o", config.experimental);
+  debug2("[config.experimental]: %o", config.experimental);
 }
 function defineSchemaConfig(config, configInput) {
   if (!configInput.schema) {
     return;
   }
   config.schema = configInput.schema;
-  debug("[config.schema]: %o", config.schema);
+  debug2("[config.schema]: %o", config.schema);
 }
 function defineMigrationsConfig(config, configInput) {
   if (!configInput.migrations) {
     return;
   }
   config.migrations = configInput.migrations;
-  debug("[config.migrations]: %o", config.migrations);
+  debug2("[config.migrations]: %o", config.migrations);
 }
 function defineTypedSqlConfig(config, configInput) {
   if (!configInput.typedSql) {
     return;
   }
   config.typedSql = configInput.typedSql;
-  debug("[config.typedSql]: %o", config.typedSql);
+  debug2("[config.typedSql]: %o", config.typedSql);
 }
 function defineViewsConfig(config, configInput) {
   if (!configInput.views) {
     return;
   }
   config.views = configInput.views;
-  debug("[config.views]: %o", config.views);
+  debug2("[config.views]: %o", config.views);
 }
 function defineTablesConfig(config, configInput) {
   if (!configInput.tables) {
     return;
   }
   config.tables = configInput.tables;
-  debug("[config.tables]: %o", config.tables);
+  debug2("[config.tables]: %o", config.tables);
 }
 function defineEnumsConfig(config, configInput) {
   if (!configInput.enums) {
     return;
   }
   config.enums = configInput.enums;
-  debug("[config.enums]: %o", config.enums);
+  debug2("[config.enums]: %o", config.enums);
 }
-function defineDatasource(config, configInput) {
-  const { datasource } = configInput;
-  Object.assign(config, { datasource });
-  debug("[config.datasource]: %o", datasource);
+function defineStudioConfig(config, configInput) {
+  if (!configInput.studio?.adapter) {
+    return;
+  }
+  const { adapter: getAdapterFactory } = configInput.studio;
+  config.studio = {
+    adapter: async () => {
+      const adapterFactory = await getAdapterFactory();
+      debug2("[config.studio.adapter]: %o", adapterFactory.adapterName);
+      return adapterFactory;
+    }
+  };
+  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 defineExtensionsConfig(config, configInput) {
   if (!configInput["extensions"]) {
     return;
   }
   config["extensions"] = configInput["extensions"];
-  debug("[config.extensions]: %o", config["extensions"]);
+  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 debug2 = Debug("prisma:config:PrismaConfig");
-var DatasourceShape = import_effect2.Schema.Struct({
-  url: import_effect2.Schema.optional(import_effect2.Schema.String),
-  shadowDatabaseUrl: import_effect2.Schema.optional(import_effect2.Schema.String)
+var debug3 = Debug("prisma:config:PrismaConfig");
+var SqlMigrationAwareDriverAdapterFactoryShape = import_effect3.Schema.declare(
+  (input) => {
+    return typeof input === "function";
+  },
+  {
+    identifier: "SqlMigrationAwareDriverAdapterFactory",
+    encode: import_effect3.identity,
+    decode: import_effect3.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 ExperimentalConfigShape = import_effect2.Schema.Struct({
-  externalTables: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
-  extensions: import_effect2.Schema.optional(import_effect2.Schema.Boolean)
+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 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)
 });
 if (false) {
   __testExperimentalConfigShapeValueA;
   __testExperimentalConfigShapeValueB;
 }
-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)
+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)
 });
 if (false) {
   __testMigrationsConfigShapeValueA;
   __testMigrationsConfigShapeValueB;
 }
-var TablesConfigShape = import_effect2.Schema.Struct({
-  external: import_effect2.Schema.optional(import_effect2.Schema.mutable(import_effect2.Schema.Array(import_effect2.Schema.String)))
+var TablesConfigShape = import_effect3.Schema.Struct({
+  external: import_effect3.Schema.optional(import_effect3.Schema.mutable(import_effect3.Schema.Array(import_effect3.Schema.String)))
 });
 if (false) {
   __testTablesConfigShapeValueA;
   __testTablesConfigShapeValueB;
 }
-var EnumsConfigShape = import_effect2.Schema.Struct({
-  external: import_effect2.Schema.optional(import_effect2.Schema.mutable(import_effect2.Schema.Array(import_effect2.Schema.String)))
+var EnumsConfigShape = import_effect3.Schema.Struct({
+  external: import_effect3.Schema.optional(import_effect3.Schema.mutable(import_effect3.Schema.Array(import_effect3.Schema.String)))
 });
 if (false) {
   __testEnumsConfigShapeValueA;
   __testEnumsConfigShapeValueB;
 }
-var ViewsConfigShape = import_effect2.Schema.Struct({
-  path: import_effect2.Schema.optional(import_effect2.Schema.String)
+var ViewsConfigShape = import_effect3.Schema.Struct({
+  path: import_effect3.Schema.optional(import_effect3.Schema.String)
 });
 if (false) {
   __testViewsConfigShapeValueA;
   __testViewsConfigShapeValueB;
 }
-var TypedSqlConfigShape = import_effect2.Schema.Struct({
-  path: import_effect2.Schema.optional(import_effect2.Schema.String)
+var TypedSqlConfigShape = import_effect3.Schema.Struct({
+  path: import_effect3.Schema.optional(import_effect3.Schema.String)
 });
 if (false) {
   __testTypedSqlConfigShapeValueA;
   __testTypedSqlConfigShapeValueB;
 }
+var PrismaStudioConfigShape = import_effect3.Schema.Struct({
+  /**
+   * Instantiates the Prisma driver adapter to use for Prisma Studio.
+   */
+  adapter: SqlMigrationAwareDriverAdapterFactoryShape
+});
+if (false) {
+  __testPrismaStudioConfigShapeValueA;
+  __testPrismaStudioConfigShapeValueB;
+}
 if (false) {
   __testPrismaConfig;
   __testPrismaConfigInternal;
 }
-var PrismaConfigShape = import_effect2.Schema.Struct({
-  experimental: import_effect2.Schema.optional(ExperimentalConfigShape),
-  datasource: import_effect2.Schema.optional(DatasourceShape),
-  schema: import_effect2.Schema.optional(import_effect2.Schema.String),
-  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 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_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`."));
+  }
   if (config.tables?.external && !experimental.externalTables) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error("The `tables.external` configuration requires `experimental.externalTables` to be set to `true`.")
     );
   }
   if (config.enums?.external && !experimental.externalTables) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error("The `enums.external` configuration requires `experimental.externalTables` to be set to `true`.")
     );
   }
   if (config.migrations?.initShadowDb && !experimental.externalTables) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error(
         "The `migrations.initShadowDb` configuration requires `experimental.externalTables` to be set to `true`."
       )
     );
   }
   if (config["extensions"] && !experimental.extensions) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error("The `extensions` configuration requires `experimental.extensions` to be set to `true`.")
     );
   }
-  return import_effect2.Either.right(config);
+  return import_effect3.Either.right(config);
 }
 function parsePrismaConfigShape(input) {
   return (0, import_Function.pipe)(
-    import_effect2.Schema.decodeUnknownEither(PrismaConfigShape, {})(input, {
+    import_effect3.Schema.decodeUnknownEither(PrismaConfigShape, {})(input, {
       onExcessProperty: "error"
     }),
-    import_effect2.Either.flatMap(validateExperimentalFeatures2)
+    import_effect3.Either.flatMap(validateExperimentalFeatures2)
   );
 }
 var PRISMA_CONFIG_INTERNAL_BRAND = Symbol.for("PrismaConfigInternal");
-var PrismaConfigInternalShape = import_effect2.Schema.Struct({
-  ...PrismaConfigShape.fields,
-  loadedFromFile: import_effect2.Schema.NullOr(import_effect2.Schema.String)
-});
+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
+        })
+      )
+    })
+  )
+);
 function brandPrismaConfigInternal(config) {
   Object.defineProperty(config, "__brand", {
     value: PRISMA_CONFIG_INTERNAL_BRAND,
@@ -460,13 +737,13 @@ function brandPrismaConfigInternal(config) {
   return config;
 }
 function parsePrismaConfigInternalShape(input) {
-  debug2("Parsing PrismaConfigInternal: %o", input);
+  debug3("Parsing PrismaConfigInternal: %o", input);
   if (typeof input === "object" && input !== null && input["__brand"] === PRISMA_CONFIG_INTERNAL_BRAND) {
-    debug2("Short-circuit: input is already a PrismaConfigInternal object");
-    return import_effect2.Either.right(input);
+    debug3("Short-circuit: input is already a PrismaConfigInternal object");
+    return import_effect3.Either.right(input);
   }
   return (0, import_Function.pipe)(
-    import_effect2.Schema.decodeUnknownEither(PrismaConfigInternalShape, {})(input, {
+    import_effect3.Schema.decodeUnknownEither(PrismaConfigInternalShape, {})(input, {
       onExcessProperty: "error"
     }),
     // Brand the output type to make `PrismaConfigInternal` opaque, without exposing the `Effect/Brand` type
@@ -475,24 +752,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_effect2.Either.map(brandPrismaConfigInternal)
+    import_effect3.Either.map(brandPrismaConfigInternal)
   );
 }
 function makePrismaConfigInternal(makeArgs) {
-  return (0, import_Function.pipe)(PrismaConfigInternalShape.make(makeArgs), brandPrismaConfigInternal);
+  return brandPrismaConfigInternal(makeArgs);
 }
 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_effect2.Either.map((config) => {
-      debug2("Parsed `PrismaConfig` shape: %o", config);
+    import_effect3.Either.map((config) => {
+      debug3("Parsed `PrismaConfig` shape: %o", config);
       return defineConfig(config);
     }),
     // Otherwise, try to parse it as a `PrismaConfigInternal` shape.
-    import_effect2.Either.orElse(() => parsePrismaConfigInternalShape(defaultExport))
+    import_effect3.Either.orElse(() => parsePrismaConfigInternalShape(defaultExport))
   );
-  if (import_effect2.Either.isLeft(parseResultEither)) {
+  if (import_effect3.Either.isLeft(parseResultEither)) {
     throw parseResultEither.left;
   }
   return parseResultEither.right;
@@ -501,14 +778,15 @@ function parseDefaultExport(defaultExport) {
 // src/defaultTestConfig.ts
 function defaultTestConfig() {
   return makePrismaConfigInternal({
-    loadedFromFile: null
+    loadedFromFile: null,
+    deprecatedPackageJson: null
   });
 }
 
 // src/env.ts
 var PrismaConfigEnvError = class extends Error {
   constructor(name) {
-    super(`Cannot resolve environment variable: ${name}.`);
+    super(`Missing required environment variable: ${name}`);
     this.name = "PrismaConfigEnvError";
   }
 };
@@ -522,16 +800,27 @@ function env(name) {
 
 // src/loadConfigFromFile.ts
 var import_node_path = __toESM(require("node:path"));
-var import_node_process = __toESM(require("node:process"));
-var debug3 = Debug("prisma:config:loadConfigFromFile");
+var import_node_process2 = __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_process.default.cwd()
+  configRoot = import_node_process2.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) {
@@ -541,9 +830,9 @@ async function loadConfigFromFile({
         diagnostics
       };
     }
-    debug3(`Config file loaded in %s`, getTime());
+    debug4(`Config file loaded in %s`, getTime());
     if (resolvedPath === null) {
-      debug3(`No config file found in the current working directory %s`, configRoot);
+      debug4(`No config file found in the current working directory %s`, configRoot);
       return { resolvedPath: null, config: defaultConfig(), diagnostics };
     }
     let parsedConfig;
@@ -566,6 +855,20 @@ async function loadConfigFromFile({
 `))
     });
     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,
@@ -621,7 +924,7 @@ async function loadConfigTsOrJs(configRoot, configFile) {
     const resolvedPath = _resolvedPath ? import_node_path.default.normalize(_resolvedPath) : void 0;
     const doesConfigFileExist = resolvedPath !== void 0 && meta !== void 0;
     if (configFile && !doesConfigFileExist) {
-      debug3(`The given config file was not found at %s`, resolvedPath);
+      debug4(`The given config file was not found at %s`, resolvedPath);
       return {
         require: null,
         resolvedPath: import_node_path.default.join(configRoot, configFile),
@@ -648,11 +951,11 @@ async function loadConfigTsOrJs(configRoot, configFile) {
     };
   } catch (e) {
     const error = e;
-    debug3("jiti import failed: %s", error.message);
+    debug4("jiti import failed: %s", error.message);
     const configFileMatch = error.message.match(/prisma\.config\.(\w+)/);
     const extension = configFileMatch?.[1];
     const filenameWithExtension = import_node_path.default.join(configRoot, extension ? `prisma.config.${extension}` : "");
-    debug3("faulty config file: %s", filenameWithExtension);
+    debug4("faulty config file: %s", filenameWithExtension);
     return {
       error: {
         _tag: "ConfigLoadError",
@@ -692,5 +995,6 @@ function transformPathsInConfigToAbsolute(prismaConfig, resolvedPath) {
   defaultTestConfig,
   defineConfig,
   env,
-  loadConfigFromFile
+  loadConfigFromFile,
+  loadConfigFromPackageJson
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/config",
-  "version": "7.2.0",
+  "version": "7.3.0-integration-prisma6-fix-cloudflare-engine.1",
   "description": "Internal package used to define and read Prisma configuration files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,10 +18,9 @@
     "empathic": "2.0.0"
   },
   "devDependencies": {
-    "dotenv": "17.2.3",
     "vitest": "3.2.4",
-    "@prisma/debug": "7.2.0",
-    "@prisma/get-platform": "7.2.0"
+    "@prisma/driver-adapter-utils": "7.3.0-integration-prisma6-fix-cloudflare-engine.1",
+    "@prisma/get-platform": "7.3.0-integration-prisma6-fix-cloudflare-engine.1"
   },
   "files": [
     "dist"