@prisma/config 6.6.0-dev.90 → 6.6.0-dev.92

package/dist/index.d.ts

@@ -93,6 +93,55 @@ declare interface DriverAdapterFactory<Query, Result> extends AdapterInfo {
 
 declare type EnvVars = Record<string, string | undefined>;
 
+declare type Error_2 = {
+    kind: 'GenericJs';
+    id: number;
+} | {
+    kind: 'UnsupportedNativeDataType';
+    type: string;
+} | {
+    kind: 'InvalidIsolationLevel';
+    level: 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;
+};
+
+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 IsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SNAPSHOT' | 'SERIALIZABLE';
 
 /**
@@ -178,7 +227,7 @@ declare type _PrismaConfigInternal<Env extends EnvVars = never> = {
     /**
      * The configuration for Prisma Migrate + Introspect
      */
-    migrate?: PrismaMigrateConfigShape<Env>;
+    migrate?: PrismaMigrateConfigInternalShape<Env>;
     /**
      * The path from where the config was loaded.
      * It's set to `null` if no config file was found and only default config is applied.
@@ -186,12 +235,16 @@ declare type _PrismaConfigInternal<Env extends EnvVars = never> = {
     loadedFromFile: string | null;
 };
 
+declare type PrismaMigrateConfigInternalShape<Env extends EnvVars = never> = {
+    adapter: (env: Env) => Promise<ErrorCapturingSqlMigrationAwareDriverAdapterFactory>;
+};
+
 declare type PrismaMigrateConfigShape<Env extends EnvVars = never> = {
     adapter: (env: Env) => Promise<SqlMigrationAwareDriverAdapterFactory>;
 };
 
 declare type PrismaStudioConfigShape<Env extends EnvVars = never> = {
-    adapter: (env: Env) => Promise<SqlDriverAdapter>;
+    adapter: (env: Env) => Promise<SqlMigrationAwareDriverAdapterFactory>;
 };
 
 declare type Provider = 'mysql' | 'postgres' | 'sqlite';
@@ -207,6 +260,17 @@ 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 interface SqlDriverAdapter extends SqlQueryable {
     /**
      * Execute multiple SQL statements separated by semicolon.

package/dist/index.js

@@ -222,6 +222,129 @@ function safeStringify(value3, indent = 2) {
   );
 }
 
+// ../driver-adapter-utils/dist/index.mjs
+function isDriverAdapterError(error) {
+  return error["name"] === "DriverAdapterError" && typeof error["cause"] === "object";
+}
+function ok(value3) {
+  return {
+    ok: true,
+    value: value3,
+    map(fn) {
+      return ok(fn(value3));
+    },
+    flatMap(fn) {
+      return fn(value3);
+    }
+  };
+}
+function err(error) {
+  return {
+    ok: false,
+    error,
+    map() {
+      return err(error);
+    },
+    flatMap() {
+      return err(error);
+    }
+  };
+}
+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;
+  }
+};
+var bindMigrationAwareSqlAdapterFactory = (adapterFactory) => {
+  const errorRegistry = new ErrorRegistryInternal();
+  const boundFactory = {
+    adapterName: adapterFactory.adapterName,
+    provider: adapterFactory.provider,
+    errorRegistry,
+    connect: async (...args2) => {
+      const ctx = await wrapAsync(errorRegistry, adapterFactory.connect.bind(adapterFactory))(...args2);
+      return ctx.map((ctx2) => bindAdapter(ctx2, errorRegistry));
+    },
+    connectToShadowDb: async (...args2) => {
+      const ctx = await wrapAsync(errorRegistry, adapterFactory.connectToShadowDb.bind(adapterFactory))(...args2);
+      return ctx.map((ctx2) => bindAdapter(ctx2, errorRegistry));
+    }
+  };
+  return boundFactory;
+};
+var bindAdapter = (adapter4, errorRegistry = new ErrorRegistryInternal()) => {
+  const boundAdapter = {
+    adapterName: adapter4.adapterName,
+    errorRegistry,
+    queryRaw: wrapAsync(errorRegistry, adapter4.queryRaw.bind(adapter4)),
+    executeRaw: wrapAsync(errorRegistry, adapter4.executeRaw.bind(adapter4)),
+    executeScript: wrapAsync(errorRegistry, adapter4.executeScript.bind(adapter4)),
+    dispose: wrapAsync(errorRegistry, adapter4.dispose.bind(adapter4)),
+    provider: adapter4.provider,
+    startTransaction: async (...args2) => {
+      const ctx = await wrapAsync(errorRegistry, adapter4.startTransaction.bind(adapter4))(...args2);
+      return ctx.map((ctx2) => bindTransaction(errorRegistry, ctx2));
+    }
+  };
+  if (adapter4.getConnectionInfo) {
+    boundAdapter.getConnectionInfo = wrapSync(errorRegistry, adapter4.getConnectionInfo.bind(adapter4));
+  }
+  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 (...args2) => {
+    try {
+      return ok(await fn(...args2));
+    } catch (error) {
+      if (isDriverAdapterError(error)) {
+        return err(error.cause);
+      }
+      const id = registry.registerNewError(error);
+      return err({ kind: "GenericJs", id });
+    }
+  };
+}
+function wrapSync(registry, fn) {
+  return (...args2) => {
+    try {
+      return ok(fn(...args2));
+    } catch (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")
+};
+
 // ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
@@ -1564,8 +1687,8 @@ var PreconditionFailure = class _PreconditionFailure extends Error {
     this.interruptExecution = interruptExecution;
     this.footprint = _PreconditionFailure.SharedFootPrint;
   }
-  static isFailure(err) {
-    return err != null && err.footprint === _PreconditionFailure.SharedFootPrint;
+  static isFailure(err2) {
+    return err2 != null && err2.footprint === _PreconditionFailure.SharedFootPrint;
   }
 };
 PreconditionFailure.SharedFootPrint = Symbol.for("fast-check/PreconditionFailure");
@@ -1930,7 +2053,7 @@ var ApplySymbol = Symbol("apply");
 function safeExtractApply(f) {
   try {
     return f.apply;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
@@ -1968,42 +2091,42 @@ var untouchedEvery = Array.prototype.every;
 function extractIndexOf(instance) {
   try {
     return instance.indexOf;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractJoin(instance) {
   try {
     return instance.join;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractMap(instance) {
   try {
     return instance.map;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractFilter(instance) {
   try {
     return instance.filter;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractPush(instance) {
   try {
     return instance.push;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractSlice(instance) {
   try {
     return instance.slice;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
@@ -2048,14 +2171,14 @@ var untouchedToISOString = Date.prototype.toISOString;
 function extractGetTime(instance) {
   try {
     return instance.getTime;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractToISOString(instance) {
   try {
     return instance.toISOString;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
@@ -2080,14 +2203,14 @@ var untouchedMapGet = Map.prototype.get;
 function extractMapSet(instance) {
   try {
     return instance.set;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractMapGet(instance) {
   try {
     return instance.get;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
@@ -2116,14 +2239,14 @@ var untouchedReplace = String.prototype.replace;
 function extractSplit(instance) {
   try {
     return instance.split;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
 function extractCharCodeAt(instance) {
   try {
     return instance.charCodeAt;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
@@ -2143,7 +2266,7 @@ var untouchedNumberToString = Number.prototype.toString;
 function extractNumberToString(instance) {
   try {
     return instance.toString;
-  } catch (err) {
+  } catch (err2) {
     return void 0;
   }
 }
@@ -2252,13 +2375,13 @@ var AsyncProperty = class _AsyncProperty {
         error: new SError("Property failed by returning false"),
         errorMessage: "Error: Property failed by returning false"
       };
-    } catch (err) {
-      if (PreconditionFailure.isFailure(err))
-        return err;
-      if (err instanceof SError && err.stack) {
-        return { error: err, errorMessage: err.stack };
+    } catch (err2) {
+      if (PreconditionFailure.isFailure(err2))
+        return err2;
+      if (err2 instanceof SError && err2.stack) {
+        return { error: err2, errorMessage: err2.stack };
       }
-      return { error: err, errorMessage: SString(err) };
+      return { error: err2, errorMessage: SString(err2) };
     } finally {
       if (!dontRunHook) {
         await this.afterEachHook();
@@ -2324,13 +2447,13 @@ var Property = class _Property {
         error: new SError("Property failed by returning false"),
         errorMessage: "Error: Property failed by returning false"
       };
-    } catch (err) {
-      if (PreconditionFailure.isFailure(err))
-        return err;
-      if (err instanceof SError && err.stack) {
-        return { error: err, errorMessage: err.stack };
+    } catch (err2) {
+      if (PreconditionFailure.isFailure(err2))
+        return err2;
+      if (err2 instanceof SError && err2.stack) {
+        return { error: err2, errorMessage: err2.stack };
       }
-      return { error: err, errorMessage: SString(err) };
+      return { error: err2, errorMessage: SString(err2) };
     } finally {
       if (!dontRunHook) {
         this.afterEachHook();
@@ -3178,7 +3301,7 @@ function stringifyInternal(value3, previousValues, getAsyncContent) {
   if (hasToStringMethod(value3)) {
     try {
       return value3[toStringMethod]();
-    } catch (err) {
+    } catch (err2) {
     }
   }
   switch (safeToString(value3)) {
@@ -3217,7 +3340,7 @@ function stringifyInternal(value3, previousValues, getAsyncContent) {
         if (typeof toStringAccessor === "function" && toStringAccessor !== Object.prototype.toString) {
           return value3.toString();
         }
-      } catch (err) {
+      } catch (err2) {
         return "[object Object]";
       }
       const mapper = (k) => `${k === "__proto__" ? '["__proto__"]' : typeof k === "symbol" ? `[${stringifyInternal(k, currentValues, getAsyncContent)}]` : safeJsonStringify(k)}:${stringifyInternal(value3[k], currentValues, getAsyncContent)}`;
@@ -4268,9 +4391,9 @@ var SchedulerImplem = class _SchedulerImplem {
         (thenTaskToBeAwaited ? task.then(() => thenTaskToBeAwaited()) : task).then((data) => {
           this.log(schedulingType, taskId, label, metadata, "resolved", data);
           return resolve(data);
-        }, (err) => {
-          this.log(schedulingType, taskId, label, metadata, "rejected", err);
-          return reject(err);
+        }, (err2) => {
+          this.log(schedulingType, taskId, label, metadata, "rejected", err2);
+          return reject(err2);
         });
       };
     });
@@ -4382,15 +4505,15 @@ var SchedulerImplem = class _SchedulerImplem {
         clearAndReplaceWatcher();
         return ret;
       });
-    }, (err) => {
+    }, (err2) => {
       taskResolved = true;
       if (awaiterPromise === null) {
         clearAndReplaceWatcher();
-        throw err;
+        throw err2;
       }
       return awaiterPromise.then(() => {
         clearAndReplaceWatcher();
-        throw err;
+        throw err2;
       });
     });
     if (this.scheduledTasks.length > 0 && this.scheduledWatchers.length === 0) {
@@ -12391,8 +12514,8 @@ var forEach3 = (iterable, f, options) => withMicroFiber((parent) => {
               pump();
             }
           });
-        } catch (err) {
-          result = exitDie2(err);
+        } catch (err2) {
+          result = exitDie2(err2);
           length2 = index;
           fibers.forEach((fiber) => fiber.unsafeInterrupt());
         }
@@ -21855,14 +21978,14 @@ var Defect = /* @__PURE__ */ transform2(Unknown, Unknown, {
   strict: true,
   decode: (u) => {
     if (isObject(u) && "message" in u && typeof u.message === "string") {
-      const err = new Error(u.message, {
+      const err2 = new Error(u.message, {
         cause: u
       });
       if ("name" in u && typeof u.name === "string") {
-        err.name = u.name;
+        err2.name = u.name;
       }
-      err.stack = "stack" in u && typeof u.stack === "string" ? u.stack : "";
-      return err;
+      err2.stack = "stack" in u && typeof u.stack === "string" ? u.stack : "";
+      return err2;
     }
     return String(u);
   },
@@ -22350,7 +22473,7 @@ function defaultConfig() {
 var debug = Debug("prisma:config:defineConfig");
 function defineConfig(configInput) {
   const config2 = defaultConfig();
-  debug("Prisma config [default]: %o", config2);
+  debug("[default]: %o", config2);
   defineSchemaConfig(config2, configInput);
   defineStudioConfig(config2, configInput);
   defineMigrateConfig(config2, configInput);
@@ -22361,60 +22484,70 @@ function defineSchemaConfig(config2, configInput) {
     return;
   }
   config2.schema = configInput.schema;
-  debug("Prisma config [schema]: %o", config2.schema);
+  debug("[config.schema]: %o", config2.schema);
 }
 function defineStudioConfig(config2, configInput) {
   if (!configInput.studio) {
     return;
   }
+  const { adapter: getAdapterFactory } = configInput.studio;
   config2.studio = {
-    adapter: configInput.studio.adapter
+    adapter: async (env) => {
+      const adapterFactory = await getAdapterFactory(env);
+      debug("[config.studio.adapter]: %o", adapterFactory.adapterName);
+      return adapterFactory;
+    }
   };
-  debug("Prisma config [studio]: %o", config2.studio);
+  debug("[config.studio]: %o", config2.studio);
 }
 function defineMigrateConfig(config2, configInput) {
   if (!configInput.migrate) {
     return;
   }
+  const { adapter: getAdapterFactory } = configInput.migrate;
   config2.migrate = {
-    adapter: configInput.migrate.adapter
+    adapter: async (env) => {
+      const adapterFactory = await getAdapterFactory(env);
+      debug("[config.migrate.adapter]: %o", adapterFactory.adapterName);
+      return bindMigrationAwareSqlAdapterFactory(adapterFactory);
+    }
   };
-  debug("Prisma config [migrate]: %o", config2.migrate);
+  debug("[config.schema]: %o", config2.migrate);
 }
 
 // src/PrismaConfig.ts
 var debug2 = Debug("prisma:config:PrismaConfig");
-var adapterShape = () => Schema_exports.declare(
+var sqlMigrationAwareDriverAdapterFactoryShape = () => Schema_exports.declare(
   (input) => {
     return input instanceof Function;
   },
   {
-    identifier: "Adapter<Env>",
+    identifier: "SqlMigrationAwareDriverAdapterFactory<Env>",
     encode: identity,
     decode: identity
   }
 );
-var migrationAwareAdapterShape = () => Schema_exports.declare(
+var errorCapturingSqlMigrationAwareDriverAdapterFactoryShape = () => Schema_exports.declare(
   (input) => {
     return input instanceof Function;
   },
   {
-    identifier: "MigrationAwareAdapter<Env>",
+    identifier: "ErrorCapturingSqlMigrationAwareDriverAdapterFactory<Env>",
     encode: identity,
     decode: identity
   }
 );
-var createPrismaStudioConfigInternalShape = () => Schema_exports.Struct({
+var createPrismaStudioConfigShape = () => Schema_exports.Struct({
   /**
    * Instantiates the Prisma driver adapter to use for Prisma Studio.
    */
-  adapter: adapterShape()
+  adapter: sqlMigrationAwareDriverAdapterFactoryShape()
 });
 var createPrismaMigrateConfigInternalShape = () => Schema_exports.Struct({
   /**
    * Instantiates the Prisma driver adapter to use for Prisma Migrate + Introspect.
    */
-  adapter: migrationAwareAdapterShape()
+  adapter: errorCapturingSqlMigrationAwareDriverAdapterFactoryShape()
 });
 if (false) {
   __testPrismaStudioConfigShapeValueA;
@@ -22439,7 +22572,7 @@ var PRISMA_CONFIG_INTERNAL_BRAND = Symbol.for("PrismaConfigInternal");
 var createPrismaConfigInternalShape = () => Schema_exports.Struct({
   earlyAccess: Schema_exports.Literal(true),
   schema: Schema_exports.optional(Schema_exports.String),
-  studio: Schema_exports.optional(createPrismaStudioConfigInternalShape()),
+  studio: Schema_exports.optional(createPrismaStudioConfigShape()),
   migrate: Schema_exports.optional(createPrismaMigrateConfigInternalShape()),
   loadedFromFile: Schema_exports.NullOr(Schema_exports.String)
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/config",
-  "version": "6.6.0-dev.90",
+  "version": "6.6.0-dev.92",
   "description": "Internal package used to define and read Prisma configuration files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,8 +22,8 @@
     "esbuild-register": "3.6.0",
     "jest": "29.7.0",
     "jest-junit": "16.0.0",
-    "@prisma/driver-adapter-utils": "6.6.0-dev.90",
-    "@prisma/get-platform": "6.6.0-dev.90"
+    "@prisma/driver-adapter-utils": "6.6.0-dev.92",
+    "@prisma/get-platform": "6.6.0-dev.92"
   },
   "files": [
     "dist"