@prisma/config 6.20.0-integration-feat-prisma-7-config.1 → 6.20.0-integration-next.3

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { Schema } from 'effect';
+
 /**
  * An interface that exposes some basic information about the
  * adapter like its name and provider type.
@@ -85,15 +87,6 @@ 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.
  */
@@ -126,7 +119,34 @@ 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.
      */
@@ -184,6 +204,116 @@ declare type LoadConfigFromFileInput = {
     configRoot?: string;
 };
 
+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.
@@ -208,11 +338,37 @@ 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 = {
-    /**
-     * The datasource URL configuration for the database connection.
-     */
-    datasource: Simplify<Datasource>;
+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;
+} & ({
+    engine: 'classic';
+    datasource: {
+        url: string;
+        shadowDatabaseUrl?: string;
+    };
+} | {
+    engine: 'js';
+    adapter: () => Promise<ErrorCapturingSqlMigrationAwareDriverAdapterFactory>;
+} | {
+    engine?: never;
+});
+
+declare type PrismaConfigUnconditional = {
     /**
      * Experimental feature gates. Each experimental feature must be explicitly enabled.
      */
@@ -247,23 +403,6 @@ export declare type PrismaConfig = {
     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>;
 };
@@ -281,10 +420,69 @@ declare interface Queryable<Query, Result> extends AdapterInfo {
     executeRaw(params: Query): Promise<number>;
 }
 
-export declare type SchemaEngineConfigInternal = {
-    datasource: Datasource;
+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 = 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

@@ -225,7 +225,129 @@ 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"),
@@ -244,16 +366,18 @@ var import_effect = require("effect");
 // src/defaultConfig.ts
 function defaultConfig() {
   return makePrismaConfigInternal({
-    loadedFromFile: null,
-    datasource: {
-      url: "<default_datasource_url>"
-    }
+    loadedFromFile: 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`."));
   }
@@ -286,7 +410,7 @@ function defineConfig(configInput) {
   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);
@@ -359,10 +483,25 @@ function defineStudioConfig(config, configInput) {
   };
   debug2("[config.studio]: %o", config.studio);
 }
-function defineDatasource(config, configInput) {
-  const { datasource } = configInput;
-  Object.assign(config, { datasource });
-  debug2("[config.datasource]: %o", datasource);
+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"]) {
@@ -384,15 +523,47 @@ var SqlMigrationAwareDriverAdapterFactoryShape = import_effect2.Schema.declare(
     decode: import_effect2.identity
   }
 );
-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 ErrorCapturingSqlMigrationAwareDriverAdapterFactoryShape = import_effect2.Schema.declare(
+  (input) => {
+    return typeof input === "function";
+  },
+  {
+    identifier: "ErrorCapturingSqlMigrationAwareDriverAdapterFactory",
+    encode: import_effect2.identity,
+    decode: import_effect2.identity
+  }
+);
+var SchemaEngineConfigClassicShape = import_effect2.Schema.Struct({
+  engine: import_effect2.Schema.Literal("classic"),
+  datasource: import_effect2.Schema.Struct({
+    url: import_effect2.Schema.String,
+    directUrl: import_effect2.Schema.optional(import_effect2.Schema.String),
+    shadowDatabaseUrl: import_effect2.Schema.optional(import_effect2.Schema.String)
+  })
+});
+var SchemaEngineConfigJsShape = import_effect2.Schema.Struct({
+  engine: import_effect2.Schema.Literal("js"),
+  adapter: SqlMigrationAwareDriverAdapterFactoryShape
+});
+var SchemaEngineConfigAbsentShape = import_effect2.Schema.Struct({
+  engine: import_effect2.Schema.optional(import_effect2.Schema.Never)
+});
+var SchemaEngineConfigShape = import_effect2.Schema.Union(
+  SchemaEngineConfigClassicShape,
+  SchemaEngineConfigJsShape,
+  SchemaEngineConfigAbsentShape
+);
+var SchemaEngineConfigJsInternal = import_effect2.Schema.Struct({
+  engine: import_effect2.Schema.Literal("js"),
+  adapter: ErrorCapturingSqlMigrationAwareDriverAdapterFactoryShape
 });
+var SchemaEngineConfigInternal = import_effect2.Schema.Union(
+  SchemaEngineConfigClassicShape,
+  SchemaEngineConfigJsInternal,
+  SchemaEngineConfigAbsentShape
+);
 var ExperimentalConfigShape = import_effect2.Schema.Struct({
+  adapter: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
   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)
@@ -452,8 +623,7 @@ if (false) {
   __testPrismaConfig;
   __testPrismaConfigInternal;
 }
-var PrismaConfigShape = import_effect2.Schema.Struct({
-  datasource: DatasourceShape,
+var PrismaConfigUnconditionalShape = import_effect2.Schema.Struct({
   experimental: import_effect2.Schema.optional(ExperimentalConfigShape),
   schema: import_effect2.Schema.optional(import_effect2.Schema.String),
   studio: import_effect2.Schema.optional(PrismaStudioConfigShape),
@@ -464,12 +634,18 @@ var PrismaConfigShape = import_effect2.Schema.Struct({
   typedSql: import_effect2.Schema.optional(TypedSqlConfigShape),
   extensions: import_effect2.Schema.optional(import_effect2.Schema.Any)
 });
+var PrismaConfigShape = import_effect2.Schema.extend(SchemaEngineConfigShape, PrismaConfigUnconditionalShape);
 if (false) {
   __testPrismaConfigValueA;
   __testPrismaConfigValueB;
 }
 function validateExperimentalFeatures2(config) {
   const experimental = config.experimental || {};
+  if (config.engine === "js" && !experimental.adapter) {
+    return import_effect2.Either.left(
+      new Error("The `engine === 'js'` configuration requires `experimental.adapter` to be set to `true`.")
+    );
+  }
   if (config.studio && !experimental.studio) {
     return import_effect2.Either.left(new Error("The `studio` configuration requires `experimental.studio` to be set to `true`."));
   }
@@ -506,10 +682,15 @@ function parsePrismaConfigShape(input) {
   );
 }
 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_effect2.Schema.extend(
+  PrismaConfigUnconditionalShape,
+  import_effect2.Schema.extend(
+    SchemaEngineConfigInternal,
+    import_effect2.Schema.Struct({
+      loadedFromFile: import_effect2.Schema.NullOr(import_effect2.Schema.String)
+    })
+  )
+);
 function brandPrismaConfigInternal(config) {
   Object.defineProperty(config, "__brand", {
     value: PRISMA_CONFIG_INTERNAL_BRAND,
@@ -539,7 +720,7 @@ function parsePrismaConfigInternalShape(input) {
   );
 }
 function makePrismaConfigInternal(makeArgs) {
-  return (0, import_Function.pipe)(PrismaConfigInternalShape.make(makeArgs), brandPrismaConfigInternal);
+  return brandPrismaConfigInternal(makeArgs);
 }
 function parseDefaultExport(defaultExport) {
   const parseResultEither = (0, import_Function.pipe)(
@@ -561,10 +742,7 @@ function parseDefaultExport(defaultExport) {
 // src/defaultTestConfig.ts
 function defaultTestConfig() {
   return makePrismaConfigInternal({
-    loadedFromFile: null,
-    datasource: {
-      url: "<default_datasource_url>"
-    }
+    loadedFromFile: null
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/config",
-  "version": "6.20.0-integration-feat-prisma-7-config.1",
+  "version": "6.20.0-integration-next.3",
   "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/driver-adapter-utils": "6.20.0-integration-feat-prisma-7-config.1",
-    "@prisma/get-platform": "6.20.0-integration-feat-prisma-7-config.1"
+    "@prisma/driver-adapter-utils": "6.20.0-integration-next.3",
+    "@prisma/get-platform": "6.20.0-integration-next.3"
   },
   "files": [
     "dist"