@prisma/client-engine-runtime 6.6.0-dev.8 → 6.6.0-dev.80

package/dist/index.mjs

@@ -1,121 +1,119 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
+// src/interpreter/generators.ts
+import cuid1 from "@bugsnag/cuid";
+import { createId as cuid2 } from "@paralleldrive/cuid2";
+import { nanoid } from "nanoid";
+import { ulid } from "ulid";
+import { v4 as uuidv4, v7 as uuidv7 } from "uuid";
+var GeneratorRegistry = class {
+  #generators = {};
+  constructor() {
+    this.register("now", new NowGenerator());
+    this.register("uuid", new UuidGenerator());
+    this.register("cuid", new CuidGenerator());
+    this.register("ulid", new UlidGenerator());
+    this.register("nanoid", new NanoIdGenerator());
+  }
+  /**
+   * Returns a snapshot of the generator registry. It's 'frozen' in time at the moment of this
+   * method being called, meaning that the built-in time-based generators will always return
+   * the same value on repeated calls as long as the same snapshot is used.
+   */
+  snapshot() {
+    return Object.create(this.#generators, {
+      now: { value: new NowGenerator() }
+    });
+  }
+  /**
+   * Registers a new generator with the given name.
+   */
+  register(name, generator) {
+    this.#generators[name] = generator;
+  }
+};
+var NowGenerator = class {
+  #now = /* @__PURE__ */ new Date();
+  generate() {
+    return this.#now.toISOString();
+  }
+};
+var UuidGenerator = class {
+  generate(arg) {
+    if (arg === 4) {
+      return uuidv4();
+    } else if (arg === 7) {
+      return uuidv7();
+    } else {
+      throw new Error("Invalid UUID generator arguments");
+    }
+  }
+};
+var CuidGenerator = class {
+  generate(arg) {
+    if (arg === 1) {
+      return cuid1();
+    } else if (arg === 2) {
+      return cuid2();
+    } else {
+      throw new Error("Invalid CUID generator arguments");
+    }
+  }
+};
+var UlidGenerator = class {
+  generate() {
+    return ulid();
+  }
+};
+var NanoIdGenerator = class {
+  generate(arg) {
+    if (typeof arg === "number") {
+      return nanoid(arg);
+    } else if (arg === void 0) {
+      return nanoid();
+    } else {
+      throw new Error("Invalid Nanoid generator arguments");
+    }
+  }
 };
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/QueryPlan.ts
 function isPrismaValuePlaceholder(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "param";
 }
+function isPrismaValueGenerator(value) {
+  return typeof value === "object" && value !== null && value["prisma__type"] === "generatorCall";
+}
 
-// src/interpreter/renderQueryTemplate.ts
-var BEGIN_REPEAT = "/* prisma-comma-repeatable-start */";
-var END_REPEAT = "/* prisma-comma-repeatable-end */";
-function renderQueryTemplate({
-  query,
-  params
-}) {
-  if (!query.includes(BEGIN_REPEAT)) {
-    return { query, params };
-  }
-  const flattenedParams = [];
-  let lastParamId = 1;
-  let result = "";
-  let templatePos = 0;
-  let state = 0 /* Normal */;
-  let stateBeforeQuote = 0 /* Normal */;
-  while (templatePos < query.length) {
-    const nextChar = query[templatePos];
-    if (state === 1 /* Quoted */ && nextChar !== '"') {
-      result += nextChar;
-      templatePos++;
-      continue;
-    }
-    if (nextChar === '"') {
-      if (state === 1 /* Quoted */) {
-        state = stateBeforeQuote;
-      } else {
-        stateBeforeQuote = state;
-        state = 1 /* Quoted */;
-      }
-      result += nextChar;
-      templatePos++;
-      continue;
-    }
-    if (query.slice(templatePos, templatePos + BEGIN_REPEAT.length) === BEGIN_REPEAT) {
-      if (state === 2 /* Repeating */) {
-        throw new Error("Nested repetition is not allowed");
-      }
-      state = 2 /* Repeating */;
-      templatePos += BEGIN_REPEAT.length;
-      result += "(";
-      continue;
-    }
-    if (query.slice(templatePos, templatePos + END_REPEAT.length) === END_REPEAT) {
-      if (state === 0 /* Normal */) {
-        throw new Error("Unmatched repetition end");
-      }
-      state = 0 /* Normal */;
-      templatePos += END_REPEAT.length;
-      result += ")";
-      continue;
-    }
-    if (nextChar === "$") {
-      const paramMatch = query.slice(templatePos + 1).match(/^\d+/);
-      if (!paramMatch) {
-        result += "$";
-        templatePos++;
-        continue;
-      }
-      templatePos += paramMatch[0].length + 1;
-      const originalParamIdx = parseInt(paramMatch[0]);
-      const paramValue = params[originalParamIdx - 1];
-      switch (state) {
-        case 0 /* Normal */: {
-          flattenedParams.push(paramValue);
-          result += `$${lastParamId++}`;
-          break;
-        }
-        case 2 /* Repeating */: {
-          const paramArray = Array.isArray(paramValue) ? paramValue : [paramValue];
-          if (paramArray.length === 0) {
-            result += "NULL";
-            break;
-          }
-          paramArray.forEach((value, idx) => {
-            flattenedParams.push(value);
-            result += `$${lastParamId++}`;
-            if (idx !== paramArray.length - 1) {
-              result += ", ";
-            }
-          });
-          break;
-        }
-        default: {
-          throw new Error(`Unexpected state: ${state}`);
-        }
-      }
-      continue;
-    }
-    result += nextChar;
-    templatePos++;
-  }
-  return {
-    query: result,
-    params: flattenedParams
-  };
+// src/utils.ts
+function assertNever(_, message) {
+  throw new Error(message);
 }
 
 // src/interpreter/renderQuery.ts
-function renderQuery({ query, params }, scope) {
-  const substitutedParams = params.map((param) => {
+function renderQuery(dbQuery, scope, generators) {
+  const queryType = dbQuery.type;
+  switch (queryType) {
+    case "rawSql":
+      return renderRawSql(dbQuery.sql, substituteParams(dbQuery.params, scope, generators));
+    case "templateSql":
+      return renderTemplateSql(
+        dbQuery.fragments,
+        dbQuery.placeholderFormat,
+        substituteParams(dbQuery.params, scope, generators)
+      );
+    default:
+      assertNever(queryType, `Invalid query type`);
+  }
+}
+function substituteParams(params, scope, generators) {
+  return params.map((param) => {
+    if (isPrismaValueGenerator(param)) {
+      const { name, args } = param.prisma__value;
+      const generator = generators[name];
+      if (!generator) {
+        throw new Error(`Encountered an unknown generator '${name}'`);
+      }
+      return generator.generate(...args);
+    }
     if (!isPrismaValuePlaceholder(param)) {
       return param;
     }
@@ -125,11 +123,48 @@ function renderQuery({ query, params }, scope) {
     }
     return value;
   });
-  const { query: renderedQuery, params: expandedParams } = renderQueryTemplate({ query, params: substitutedParams });
-  const argTypes = expandedParams.map((param) => toArgType(param));
+}
+function renderTemplateSql(fragments, placeholderFormat, params) {
+  let paramIndex = 0;
+  let placeholderNumber = 1;
+  const flattenedParams = [];
+  const sql = fragments.map((fragment) => {
+    const fragmentType = fragment.type;
+    switch (fragmentType) {
+      case "parameter":
+        if (paramIndex >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        flattenedParams.push(params[paramIndex++]);
+        return formatPlaceholder(placeholderFormat, placeholderNumber++);
+      case "stringChunk":
+        return fragment.value;
+      case "parameterTuple": {
+        if (paramIndex >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        const paramValue = params[paramIndex++];
+        const paramArray = Array.isArray(paramValue) ? paramValue : [paramValue];
+        const placeholders = paramArray.length == 0 ? "NULL" : paramArray.map((value) => {
+          flattenedParams.push(value);
+          return formatPlaceholder(placeholderFormat, placeholderNumber++);
+        }).join(",");
+        return `(${placeholders})`;
+      }
+      default:
+        assertNever(fragmentType, "Invalid fragment type");
+    }
+  }).join("");
+  return renderRawSql(sql, flattenedParams);
+}
+function formatPlaceholder(placeholderFormat, placeholderNumber) {
+  return placeholderFormat.hasNumbering ? `${placeholderFormat.prefix}${placeholderNumber}` : placeholderFormat.prefix;
+}
+function renderRawSql(sql, params) {
+  const argTypes = params.map((param) => toArgType(param));
   return {
-    sql: renderedQuery,
-    args: expandedParams,
+    sql,
+    args: params,
     argTypes
   };
 }
@@ -198,24 +233,23 @@ function serialize(resultSet) {
 }
 
 // src/interpreter/QueryInterpreter.ts
-var _queryable, _placeholderValues, _onQuery, _QueryInterpreter_instances, withQueryEvent_fn;
 var QueryInterpreter = class {
+  #queryable;
+  #placeholderValues;
+  #onQuery;
+  #generators = new GeneratorRegistry();
   constructor({ queryable, placeholderValues, onQuery }) {
-    __privateAdd(this, _QueryInterpreter_instances);
-    __privateAdd(this, _queryable);
-    __privateAdd(this, _placeholderValues);
-    __privateAdd(this, _onQuery);
-    __privateSet(this, _queryable, queryable);
-    __privateSet(this, _placeholderValues, placeholderValues);
-    __privateSet(this, _onQuery, onQuery);
+    this.#queryable = queryable;
+    this.#placeholderValues = placeholderValues;
+    this.#onQuery = onQuery;
   }
   async run(queryPlan) {
-    return this.interpretNode(queryPlan, __privateGet(this, _placeholderValues));
+    return this.interpretNode(queryPlan, this.#placeholderValues, this.#generators.snapshot());
   }
-  async interpretNode(node, scope) {
+  async interpretNode(node, scope, generators) {
     switch (node.type) {
       case "seq": {
-        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return results[results.length - 1];
       }
       case "get": {
@@ -225,10 +259,10 @@ var QueryInterpreter = class {
         const nestedScope = Object.create(scope);
         await Promise.all(
           node.args.bindings.map(async (binding) => {
-            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope);
+            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope, generators);
           })
         );
-        return this.interpretNode(node.args.expr, nestedScope);
+        return this.interpretNode(node.args.expr, nestedScope, generators);
       }
       case "getFirstNonEmpty": {
         for (const name of node.args.names) {
@@ -240,41 +274,31 @@ var QueryInterpreter = class {
         return [];
       }
       case "concat": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return parts.reduce((acc, part) => acc.concat(asList(part)), []);
       }
       case "sum": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
       }
       case "execute": {
-        const query = renderQuery(node.args, scope);
-        return __privateMethod(this, _QueryInterpreter_instances, withQueryEvent_fn).call(this, query, async () => {
-          const result = await __privateGet(this, _queryable).executeRaw(query);
-          if (result.ok) {
-            return result.value;
-          } else {
-            throw result.error;
-          }
+        const query = renderQuery(node.args, scope, generators);
+        return this.#withQueryEvent(query, async () => {
+          return await this.#queryable.executeRaw(query);
         });
       }
       case "query": {
-        const query = renderQuery(node.args, scope);
-        return __privateMethod(this, _QueryInterpreter_instances, withQueryEvent_fn).call(this, query, async () => {
-          const result = await __privateGet(this, _queryable).queryRaw(query);
-          if (result.ok) {
-            return serialize(result.value);
-          } else {
-            throw result.error;
-          }
+        const query = renderQuery(node.args, scope, generators);
+        return this.#withQueryEvent(query, async () => {
+          return serialize(await this.#queryable.queryRaw(query));
         });
       }
       case "reverse": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         return Array.isArray(value) ? value.reverse() : value;
       }
       case "unique": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         if (!Array.isArray(value)) {
           return value;
         }
@@ -284,22 +308,22 @@ var QueryInterpreter = class {
         return value[0] ?? null;
       }
       case "required": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
         return value;
       }
       case "mapField": {
-        const value = await this.interpretNode(node.args.records, scope);
+        const value = await this.interpretNode(node.args.records, scope, generators);
         return mapField(value, node.args.field);
       }
       case "join": {
-        const parent = await this.interpretNode(node.args.parent, scope);
+        const parent = await this.interpretNode(node.args.parent, scope, generators);
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: await this.interpretNode(joinExpr.child, scope)
+            childRecords: await this.interpretNode(joinExpr.child, scope, generators)
           }))
         );
         if (Array.isArray(parent)) {
@@ -316,24 +340,19 @@ var QueryInterpreter = class {
       }
     }
   }
-};
-_queryable = new WeakMap();
-_placeholderValues = new WeakMap();
-_onQuery = new WeakMap();
-_QueryInterpreter_instances = new WeakSet();
-withQueryEvent_fn = async function(query, execute) {
-  var _a;
-  const timestamp = /* @__PURE__ */ new Date();
-  const startInstant = performance.now();
-  const result = await execute();
-  const endInstant = performance.now();
-  (_a = __privateGet(this, _onQuery)) == null ? void 0 : _a.call(this, {
-    timestamp,
-    duration: endInstant - startInstant,
-    query: query.sql,
-    params: query.args
-  });
-  return result;
+  async #withQueryEvent(query, execute) {
+    const timestamp = /* @__PURE__ */ new Date();
+    const startInstant = performance.now();
+    const result = await execute();
+    const endInstant = performance.now();
+    this.#onQuery?.({
+      timestamp,
+      duration: endInstant - startInstant,
+      query: query.sql,
+      params: query.args
+    });
+    return result;
+  }
 };
 function isEmpty(value) {
   if (Array.isArray(value)) {
@@ -391,22 +410,16 @@ function childRecordMatchesParent(childRecord, parentRecord, joinExpr) {
   return true;
 }
 
-// src/transactionManager/Transaction.ts
-var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
-  IsolationLevel2["ReadUncommitted"] = "ReadUncommitted";
-  IsolationLevel2["ReadCommitted"] = "ReadCommitted";
-  IsolationLevel2["RepeatableRead"] = "RepeatableRead";
-  IsolationLevel2["Snapshot"] = "Snapshot";
-  IsolationLevel2["Serializable"] = "Serializable";
-  return IsolationLevel2;
-})(IsolationLevel || {});
-
 // src/transactionManager/TransactionManager.ts
 import Debug from "@prisma/debug";
 
-// src/utils.ts
-function assertNever(_, message) {
-  throw new Error(message);
+// src/crypto.ts
+async function getCrypto() {
+  return globalThis.crypto ?? await import("node:crypto");
+}
+async function randomUUID() {
+  const crypto = await getCrypto();
+  return crypto.randomUUID();
 }
 
 // src/transactionManager/TransactionManagerErrors.ts
@@ -414,8 +427,8 @@ var TransactionManagerError = class extends Error {
   constructor(message, meta) {
     super("Transaction API error: " + message);
     this.meta = meta;
-    __publicField(this, "code", "P2028");
   }
+  code = "P2028";
 };
 var TransactionDriverAdapterError = class extends TransactionManagerError {
   constructor(message, errorParams) {
@@ -465,35 +478,23 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
 
 // src/transactionManager/TransactionManager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
-var isolationLevelMap = {
-  ReadUncommitted: "READ UNCOMMITTED",
-  ReadCommitted: "READ COMMITTED",
-  RepeatableRead: "REPEATABLE READ",
-  Snapshot: "SNAPSHOT",
-  Serializable: "SERIALIZABLE"
-};
 var debug = Debug("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
-var ISOLATION_LEVEL_QUERY = (isolationLevel) => ({
-  sql: "SET TRANSACTION ISOLATION LEVEL " + isolationLevelMap[isolationLevel],
-  args: [],
-  argTypes: []
-});
 var TransactionManager = class {
+  // The map of active transactions.
+  transactions = /* @__PURE__ */ new Map();
+  // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
+  // Used to provide better error messages than a generic "transaction not found".
+  closedTransactions = [];
+  driverAdapter;
   constructor({ driverAdapter }) {
-    // The map of active transactions.
-    __publicField(this, "transactions", /* @__PURE__ */ new Map());
-    // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
-    // Used to provide better error messages than a generic "transaction not found".
-    __publicField(this, "closedTransactions", []);
-    __publicField(this, "driverAdapter");
     this.driverAdapter = driverAdapter;
   }
   async startTransaction(options) {
     const validatedOptions = this.validateOptions(options);
     const transaction = {
-      id: globalThis.crypto.randomUUID(),
+      id: await randomUUID(),
       status: "waiting",
       timer: void 0,
       timeout: validatedOptions.timeout,
@@ -502,28 +503,17 @@ var TransactionManager = class {
     };
     this.transactions.set(transaction.id, transaction);
     transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.maxWait);
-    const txContext = await this.driverAdapter.transactionContext();
-    if (!txContext.ok)
-      throw new TransactionDriverAdapterError("Failed to start transaction.", {
-        driverAdapterError: txContext.error
-      });
-    if (this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
-      await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
-    }
-    const startedTransaction = await txContext.value.startTransaction();
-    if (!startedTransaction.ok)
+    let startedTransaction;
+    try {
+      startedTransaction = await this.driverAdapter.startTransaction(validatedOptions.isolationLevel);
+    } catch (error) {
       throw new TransactionDriverAdapterError("Failed to start transaction.", {
-        driverAdapterError: startedTransaction.error
+        driverAdapterError: error
       });
-    if (!startedTransaction.value.options.usePhantomQuery) {
-      await startedTransaction.value.executeRaw({ sql: "BEGIN", args: [], argTypes: [] });
-      if (!this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
-        await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
-      }
     }
     switch (transaction.status) {
       case "waiting":
-        transaction.transaction = startedTransaction.value;
+        transaction.transaction = startedTransaction;
         clearTimeout(transaction.timer);
         transaction.timer = void 0;
         transaction.status = "running";
@@ -603,20 +593,24 @@ var TransactionManager = class {
     debug("Closing transaction.", { transactionId: tx.id, status });
     tx.status = status;
     if (tx.transaction && status === "committed") {
-      const result = await tx.transaction.commit();
-      if (!result.ok)
+      try {
+        await tx.transaction.commit();
+      } catch (error) {
         throw new TransactionDriverAdapterError("Failed to commit transaction.", {
-          driverAdapterError: result.error
+          driverAdapterError: error
         });
+      }
       if (!tx.transaction.options.usePhantomQuery) {
         await tx.transaction.executeRaw(COMMIT_QUERY());
       }
     } else if (tx.transaction) {
-      const result = await tx.transaction.rollback();
-      if (!result.ok)
+      try {
+        await tx.transaction.rollback();
+      } catch (error) {
         throw new TransactionDriverAdapterError("Failed to rollback transaction.", {
-          driverAdapterError: result.error
+          driverAdapterError: error
         });
+      }
       if (!tx.transaction.options.usePhantomQuery) {
         await tx.transaction.executeRaw(ROLLBACK_QUERY());
       }
@@ -632,24 +626,18 @@ var TransactionManager = class {
   validateOptions(options) {
     if (!options.timeout) throw new TransactionManagerError("timeout is required");
     if (!options.maxWait) throw new TransactionManagerError("maxWait is required");
-    if (options.isolationLevel === "Snapshot" /* Snapshot */)
-      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
-    if (this.driverAdapter.provider === "sqlite" && options.isolationLevel && options.isolationLevel !== "Serializable" /* Serializable */)
-      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
+    if (options.isolationLevel === "SNAPSHOT") throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
     return {
       ...options,
       timeout: options.timeout,
       maxWait: options.maxWait
     };
   }
-  requiresSettingIsolationLevelFirst() {
-    return this.driverAdapter.provider === "mysql";
-  }
 };
 export {
-  IsolationLevel,
   QueryInterpreter,
   TransactionManager,
   TransactionManagerError,
+  isPrismaValueGenerator,
   isPrismaValuePlaceholder
 };

package/dist/interpreter/QueryInterpreter.d.ts

@@ -1,8 +1,8 @@
-import { ErrorCapturingSqlQueryable } from '@prisma/driver-adapter-utils';
+import { SqlQueryable } from '@prisma/driver-adapter-utils';
 import { QueryEvent } from '../events';
 import { QueryPlanNode } from '../QueryPlan';
 export type QueryInterpreterOptions = {
-    queryable: ErrorCapturingSqlQueryable;
+    queryable: SqlQueryable;
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
 };

package/dist/interpreter/generators.d.ts

@@ -0,0 +1,21 @@
+import { PrismaValue } from '../QueryPlan';
+export declare class GeneratorRegistry {
+    #private;
+    constructor();
+    /**
+     * Returns a snapshot of the generator registry. It's 'frozen' in time at the moment of this
+     * method being called, meaning that the built-in time-based generators will always return
+     * the same value on repeated calls as long as the same snapshot is used.
+     */
+    snapshot(): Readonly<GeneratorRegistrySnapshot>;
+    /**
+     * Registers a new generator with the given name.
+     */
+    register(name: string, generator: ValueGenerator): void;
+}
+export interface GeneratorRegistrySnapshot {
+    [key: string]: ValueGenerator;
+}
+export interface ValueGenerator {
+    generate(...args: PrismaValue[]): PrismaValue;
+}

package/dist/interpreter/renderQuery.d.ts

@@ -1,4 +1,5 @@
 import { SqlQuery } from '@prisma/driver-adapter-utils';
-import { QueryPlanDbQuery } from '../QueryPlan';
+import type { QueryPlanDbQuery } from '../QueryPlan';
+import { GeneratorRegistrySnapshot } from './generators';
 import { ScopeBindings } from './scope';
-export declare function renderQuery({ query, params }: QueryPlanDbQuery, scope: ScopeBindings): SqlQuery;
+export declare function renderQuery(dbQuery: QueryPlanDbQuery, scope: ScopeBindings, generators: GeneratorRegistrySnapshot): SqlQuery;

package/dist/interpreter/renderQuery.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transactionManager/Transaction.d.ts

@@ -1,10 +1,4 @@
-export declare const enum IsolationLevel {
-    ReadUncommitted = "ReadUncommitted",
-    ReadCommitted = "ReadCommitted",
-    RepeatableRead = "RepeatableRead",
-    Snapshot = "Snapshot",
-    Serializable = "Serializable"
-}
+import type { IsolationLevel } from '@prisma/driver-adapter-utils';
 export type Options = {
     maxWait?: number;
     timeout?: number;