@prisma/client-engine-runtime 7.3.0-dev.14 → 7.3.0-dev.16

package/dist/index.d.mts

@@ -249,30 +249,24 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, sqlCommenter, }: QueryInterpreterOptions);
+    constructor({ onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, }: QueryInterpreterOptions);
     static forSql(options: {
-        transactionManager: QueryInterpreterTransactionManager;
-        placeholderValues: Record<string, unknown>;
         onQuery?: (event: QueryEvent) => void;
         tracingHelper: TracingHelper;
         provider?: SchemaProvider;
         connectionInfo?: ConnectionInfo;
-        sqlCommenter?: QueryInterpreterSqlCommenter;
     }): QueryInterpreter;
-    run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
+    run(queryPlan: QueryPlanNode, options: QueryRuntimeOptions): Promise<unknown>;
     private interpretNode;
 }
 
 export declare type QueryInterpreterOptions = {
-    transactionManager: QueryInterpreterTransactionManager;
-    placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
     tracingHelper: TracingHelper;
     serializer: (results: SqlResultSet) => Value;
     rawSerializer?: (results: SqlResultSet) => Value;
     provider?: SchemaProvider;
     connectionInfo?: ConnectionInfo;
-    sqlCommenter?: QueryInterpreterSqlCommenter;
 };
 
 export declare type QueryInterpreterSqlCommenter = {
@@ -414,6 +408,13 @@ export declare type QueryPlanNode = {
     };
 };
 
+declare type QueryRuntimeOptions = {
+    queryable: SqlQueryable;
+    transactionManager: QueryInterpreterTransactionManager;
+    scope: Record<string, unknown>;
+    sqlCommenter?: QueryInterpreterSqlCommenter;
+};
+
 export declare type RawResponse = {
     columns: string[];
     types: string[];

package/dist/index.d.ts

@@ -249,30 +249,24 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, sqlCommenter, }: QueryInterpreterOptions);
+    constructor({ onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, }: QueryInterpreterOptions);
     static forSql(options: {
-        transactionManager: QueryInterpreterTransactionManager;
-        placeholderValues: Record<string, unknown>;
         onQuery?: (event: QueryEvent) => void;
         tracingHelper: TracingHelper;
         provider?: SchemaProvider;
         connectionInfo?: ConnectionInfo;
-        sqlCommenter?: QueryInterpreterSqlCommenter;
     }): QueryInterpreter;
-    run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
+    run(queryPlan: QueryPlanNode, options: QueryRuntimeOptions): Promise<unknown>;
     private interpretNode;
 }
 
 export declare type QueryInterpreterOptions = {
-    transactionManager: QueryInterpreterTransactionManager;
-    placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
     tracingHelper: TracingHelper;
     serializer: (results: SqlResultSet) => Value;
     rawSerializer?: (results: SqlResultSet) => Value;
     provider?: SchemaProvider;
     connectionInfo?: ConnectionInfo;
-    sqlCommenter?: QueryInterpreterSqlCommenter;
 };
 
 export declare type QueryInterpreterSqlCommenter = {
@@ -414,6 +408,13 @@ export declare type QueryPlanNode = {
     };
 };
 
+declare type QueryRuntimeOptions = {
+    queryable: SqlQueryable;
+    transactionManager: QueryInterpreterTransactionManager;
+    scope: Record<string, unknown>;
+    sqlCommenter?: QueryInterpreterSqlCommenter;
+};
+
 export declare type RawResponse = {
     columns: string[];
     types: string[];

package/dist/index.js

@@ -1485,8 +1485,6 @@ function getErrorCode2(error) {
 
 // src/interpreter/query-interpreter.ts
 var QueryInterpreter = class _QueryInterpreter {
-  #transactionManager;
-  #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
   #tracingHelper;
@@ -1494,76 +1492,66 @@ var QueryInterpreter = class _QueryInterpreter {
   #rawSerializer;
   #provider;
   #connectionInfo;
-  #sqlCommenter;
   constructor({
-    transactionManager,
-    placeholderValues,
     onQuery,
     tracingHelper,
     serializer,
     rawSerializer,
     provider,
-    connectionInfo,
-    sqlCommenter
+    connectionInfo
   }) {
-    this.#transactionManager = transactionManager;
-    this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
     this.#tracingHelper = tracingHelper;
     this.#serializer = serializer;
     this.#rawSerializer = rawSerializer ?? serializer;
     this.#provider = provider;
     this.#connectionInfo = connectionInfo;
-    this.#sqlCommenter = sqlCommenter;
   }
   static forSql(options) {
     return new _QueryInterpreter({
-      transactionManager: options.transactionManager,
-      placeholderValues: options.placeholderValues,
       onQuery: options.onQuery,
       tracingHelper: options.tracingHelper,
       serializer: serializeSql,
       rawSerializer: serializeRawSql,
       provider: options.provider,
-      connectionInfo: options.connectionInfo,
-      sqlCommenter: options.sqlCommenter
+      connectionInfo: options.connectionInfo
     });
   }
-  async run(queryPlan, queryable) {
-    const { value } = await this.interpretNode(
-      queryPlan,
-      queryable,
-      this.#placeholderValues,
-      this.#generators.snapshot()
-    ).catch((e) => rethrowAsUserFacing(e));
+  async run(queryPlan, options) {
+    const { value } = await this.interpretNode(queryPlan, {
+      ...options,
+      generators: this.#generators.snapshot()
+    }).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
-  async interpretNode(node, queryable, scope, generators) {
+  async interpretNode(node, context) {
     switch (node.type) {
       case "value": {
-        return { value: evaluateArg(node.args, scope, generators) };
+        return {
+          value: evaluateArg(node.args, context.scope, context.generators)
+        };
       }
       case "seq": {
         let result;
         for (const arg of node.args) {
-          result = await this.interpretNode(arg, queryable, scope, generators);
+          result = await this.interpretNode(arg, context);
         }
         return result ?? { value: void 0 };
       }
       case "get": {
-        return { value: scope[node.args.name] };
+        return { value: context.scope[node.args.name] };
       }
       case "let": {
-        const nestedScope = Object.create(scope);
+        const nestedScope = Object.create(context.scope);
         for (const binding of node.args.bindings) {
-          const { value } = await this.interpretNode(binding.expr, queryable, nestedScope, generators);
+          const { value } = await this.interpretNode(binding.expr, { ...context, scope: nestedScope });
           nestedScope[binding.name] = value;
         }
-        return this.interpretNode(node.args.expr, queryable, nestedScope, generators);
+        return this.interpretNode(node.args.expr, { ...context, scope: nestedScope });
       }
       case "getFirstNonEmpty": {
         for (const name of node.args.names) {
-          const value = scope[name];
+          const value = context.scope[name];
           if (!isEmpty(value)) {
             return { value };
           }
@@ -1572,7 +1560,7 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "concat": {
         const parts = await Promise.all(
-          node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators).then((res) => res.value))
+          node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
         );
         return {
           value: parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : []
@@ -1580,21 +1568,21 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "sum": {
         const parts = await Promise.all(
-          node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators).then((res) => res.value))
+          node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
         );
         return {
           value: parts.length > 0 ? parts.reduce((acc, part) => asNumber2(acc) + asNumber2(part)) : 0
         };
       }
       case "execute": {
-        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        const queries = renderQuery(node.args, context.scope, context.generators, this.#maxChunkSize());
         let sum = 0;
         for (const query of queries) {
-          const commentedQuery = this.#applyComments(query);
+          const commentedQuery = applyComments(query, context.sqlCommenter);
           sum += await this.#withQuerySpanAndEvent(
             commentedQuery,
-            queryable,
-            () => queryable.executeRaw(commentedQuery).catch(
+            context.queryable,
+            () => context.queryable.executeRaw(commentedQuery).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1602,14 +1590,14 @@ var QueryInterpreter = class _QueryInterpreter {
         return { value: sum };
       }
       case "query": {
-        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        const queries = renderQuery(node.args, context.scope, context.generators, this.#maxChunkSize());
         let results;
         for (const query of queries) {
-          const commentedQuery = this.#applyComments(query);
+          const commentedQuery = applyComments(query, context.sqlCommenter);
           const result = await this.#withQuerySpanAndEvent(
             commentedQuery,
-            queryable,
-            () => queryable.queryRaw(commentedQuery).catch(
+            context.queryable,
+            () => context.queryable.queryRaw(commentedQuery).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1626,11 +1614,11 @@ var QueryInterpreter = class _QueryInterpreter {
         };
       }
       case "reverse": {
-        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, context);
         return { value: Array.isArray(value) ? value.reverse() : value, lastInsertId };
       }
       case "unique": {
-        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, context);
         if (!Array.isArray(value)) {
           return { value, lastInsertId };
         }
@@ -1640,38 +1628,38 @@ var QueryInterpreter = class _QueryInterpreter {
         return { value: value[0] ?? null, lastInsertId };
       }
       case "required": {
-        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, context);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
         return { value, lastInsertId };
       }
       case "mapField": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.records, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.records, context);
         return { value: mapField2(value, node.args.field), lastInsertId };
       }
       case "join": {
-        const { value: parent, lastInsertId } = await this.interpretNode(node.args.parent, queryable, scope, generators);
+        const { value: parent, lastInsertId } = await this.interpretNode(node.args.parent, context);
         if (parent === null) {
           return { value: null, lastInsertId };
         }
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: (await this.interpretNode(joinExpr.child, queryable, scope, generators)).value
+            childRecords: (await this.interpretNode(joinExpr.child, context)).value
           }))
         );
         return { value: attachChildrenToParents(parent, children), lastInsertId };
       }
       case "transaction": {
-        if (!this.#transactionManager.enabled) {
-          return this.interpretNode(node.args, queryable, scope, generators);
+        if (!context.transactionManager.enabled) {
+          return this.interpretNode(node.args, context);
         }
-        const transactionManager = this.#transactionManager.manager;
+        const transactionManager = context.transactionManager.manager;
         const transactionInfo = await transactionManager.startInternalTransaction();
         const transaction = await transactionManager.getTransaction(transactionInfo, "query");
         try {
-          const value = await this.interpretNode(node.args, transaction, scope, generators);
+          const value = await this.interpretNode(node.args, { ...context, queryable: transaction });
           await transactionManager.commitTransaction(transactionInfo.id);
           return value;
         } catch (e) {
@@ -1680,49 +1668,49 @@ var QueryInterpreter = class _QueryInterpreter {
         }
       }
       case "dataMap": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         return { value: applyDataMap(value, node.args.structure, node.args.enums), lastInsertId };
       }
       case "validate": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         performValidation(value, node.args.rules, node.args);
         return { value, lastInsertId };
       }
       case "if": {
-        const { value } = await this.interpretNode(node.args.value, queryable, scope, generators);
+        const { value } = await this.interpretNode(node.args.value, context);
         if (doesSatisfyRule(value, node.args.rule)) {
-          return await this.interpretNode(node.args.then, queryable, scope, generators);
+          return await this.interpretNode(node.args.then, context);
         } else {
-          return await this.interpretNode(node.args.else, queryable, scope, generators);
+          return await this.interpretNode(node.args.else, context);
         }
       }
       case "unit": {
         return { value: void 0 };
       }
       case "diff": {
-        const { value: from } = await this.interpretNode(node.args.from, queryable, scope, generators);
-        const { value: to } = await this.interpretNode(node.args.to, queryable, scope, generators);
+        const { value: from } = await this.interpretNode(node.args.from, context);
+        const { value: to } = await this.interpretNode(node.args.to, context);
         const keyGetter = (item) => item !== null ? getRecordKey(asRecord(item), node.args.fields) : null;
         const toSet = new Set(asList(to).map(keyGetter));
         return { value: asList(from).filter((item) => !toSet.has(keyGetter(item))) };
       }
       case "process": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         return { value: processRecords(value, node.args.operations), lastInsertId };
       }
       case "initializeRecord": {
-        const { lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { lastInsertId } = await this.interpretNode(node.args.expr, context);
         const record = {};
         for (const [key, initializer] of Object.entries(node.args.fields)) {
-          record[key] = evalFieldInitializer(initializer, lastInsertId, scope, generators);
+          record[key] = evalFieldInitializer(initializer, lastInsertId, context.scope, context.generators);
         }
         return { value: record, lastInsertId };
       }
       case "mapRecord": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         const record = value === null ? {} : asRecord(value);
         for (const [key, entry] of Object.entries(node.args.fields)) {
-          record[key] = evalFieldOperation(entry, record[key], scope, generators);
+          record[key] = evalFieldOperation(entry, record[key], context.scope, context.generators);
         }
         return { value: record, lastInsertId };
       }
@@ -1767,22 +1755,6 @@ var QueryInterpreter = class _QueryInterpreter {
       onQuery: this.#onQuery
     });
   }
-  #applyComments(query) {
-    if (!this.#sqlCommenter || this.#sqlCommenter.plugins.length === 0) {
-      return query;
-    }
-    const comment = buildSqlComment(this.#sqlCommenter.plugins, {
-      query: this.#sqlCommenter.queryInfo,
-      sql: query.sql
-    });
-    if (!comment) {
-      return query;
-    }
-    return {
-      ...query,
-      sql: appendSqlComment(query.sql, comment)
-    };
-  }
 };
 function isEmpty(value) {
   if (Array.isArray(value)) {
@@ -1883,6 +1855,22 @@ function evalFieldOperation(op, value, scope, generators) {
       assertNever(op, `Unexpected field operation type: ${op["type"]}`);
   }
 }
+function applyComments(query, sqlCommenter) {
+  if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
+    return query;
+  }
+  const comment = buildSqlComment(sqlCommenter.plugins, {
+    query: sqlCommenter.queryInfo,
+    sql: query.sql
+  });
+  if (!comment) {
+    return query;
+  }
+  return {
+    ...query,
+    sql: appendSqlComment(query.sql, comment)
+  };
+}
 
 // src/raw-json-protocol.ts
 var import_client_runtime_utils4 = require("@prisma/client-runtime-utils");

package/dist/index.mjs

@@ -1434,8 +1434,6 @@ function getErrorCode2(error) {
 
 // src/interpreter/query-interpreter.ts
 var QueryInterpreter = class _QueryInterpreter {
-  #transactionManager;
-  #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
   #tracingHelper;
@@ -1443,76 +1441,66 @@ var QueryInterpreter = class _QueryInterpreter {
   #rawSerializer;
   #provider;
   #connectionInfo;
-  #sqlCommenter;
   constructor({
-    transactionManager,
-    placeholderValues,
     onQuery,
     tracingHelper,
     serializer,
     rawSerializer,
     provider,
-    connectionInfo,
-    sqlCommenter
+    connectionInfo
   }) {
-    this.#transactionManager = transactionManager;
-    this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
     this.#tracingHelper = tracingHelper;
     this.#serializer = serializer;
     this.#rawSerializer = rawSerializer ?? serializer;
     this.#provider = provider;
     this.#connectionInfo = connectionInfo;
-    this.#sqlCommenter = sqlCommenter;
   }
   static forSql(options) {
     return new _QueryInterpreter({
-      transactionManager: options.transactionManager,
-      placeholderValues: options.placeholderValues,
       onQuery: options.onQuery,
       tracingHelper: options.tracingHelper,
       serializer: serializeSql,
       rawSerializer: serializeRawSql,
       provider: options.provider,
-      connectionInfo: options.connectionInfo,
-      sqlCommenter: options.sqlCommenter
+      connectionInfo: options.connectionInfo
     });
   }
-  async run(queryPlan, queryable) {
-    const { value } = await this.interpretNode(
-      queryPlan,
-      queryable,
-      this.#placeholderValues,
-      this.#generators.snapshot()
-    ).catch((e) => rethrowAsUserFacing(e));
+  async run(queryPlan, options) {
+    const { value } = await this.interpretNode(queryPlan, {
+      ...options,
+      generators: this.#generators.snapshot()
+    }).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
-  async interpretNode(node, queryable, scope, generators) {
+  async interpretNode(node, context) {
     switch (node.type) {
       case "value": {
-        return { value: evaluateArg(node.args, scope, generators) };
+        return {
+          value: evaluateArg(node.args, context.scope, context.generators)
+        };
       }
       case "seq": {
         let result;
         for (const arg of node.args) {
-          result = await this.interpretNode(arg, queryable, scope, generators);
+          result = await this.interpretNode(arg, context);
         }
         return result ?? { value: void 0 };
       }
       case "get": {
-        return { value: scope[node.args.name] };
+        return { value: context.scope[node.args.name] };
       }
       case "let": {
-        const nestedScope = Object.create(scope);
+        const nestedScope = Object.create(context.scope);
         for (const binding of node.args.bindings) {
-          const { value } = await this.interpretNode(binding.expr, queryable, nestedScope, generators);
+          const { value } = await this.interpretNode(binding.expr, { ...context, scope: nestedScope });
           nestedScope[binding.name] = value;
         }
-        return this.interpretNode(node.args.expr, queryable, nestedScope, generators);
+        return this.interpretNode(node.args.expr, { ...context, scope: nestedScope });
       }
       case "getFirstNonEmpty": {
         for (const name of node.args.names) {
-          const value = scope[name];
+          const value = context.scope[name];
           if (!isEmpty(value)) {
             return { value };
           }
@@ -1521,7 +1509,7 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "concat": {
         const parts = await Promise.all(
-          node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators).then((res) => res.value))
+          node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
         );
         return {
           value: parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : []
@@ -1529,21 +1517,21 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "sum": {
         const parts = await Promise.all(
-          node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators).then((res) => res.value))
+          node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
         );
         return {
           value: parts.length > 0 ? parts.reduce((acc, part) => asNumber2(acc) + asNumber2(part)) : 0
         };
       }
       case "execute": {
-        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        const queries = renderQuery(node.args, context.scope, context.generators, this.#maxChunkSize());
         let sum = 0;
         for (const query of queries) {
-          const commentedQuery = this.#applyComments(query);
+          const commentedQuery = applyComments(query, context.sqlCommenter);
           sum += await this.#withQuerySpanAndEvent(
             commentedQuery,
-            queryable,
-            () => queryable.executeRaw(commentedQuery).catch(
+            context.queryable,
+            () => context.queryable.executeRaw(commentedQuery).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1551,14 +1539,14 @@ var QueryInterpreter = class _QueryInterpreter {
         return { value: sum };
       }
       case "query": {
-        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        const queries = renderQuery(node.args, context.scope, context.generators, this.#maxChunkSize());
         let results;
         for (const query of queries) {
-          const commentedQuery = this.#applyComments(query);
+          const commentedQuery = applyComments(query, context.sqlCommenter);
           const result = await this.#withQuerySpanAndEvent(
             commentedQuery,
-            queryable,
-            () => queryable.queryRaw(commentedQuery).catch(
+            context.queryable,
+            () => context.queryable.queryRaw(commentedQuery).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1575,11 +1563,11 @@ var QueryInterpreter = class _QueryInterpreter {
         };
       }
       case "reverse": {
-        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, context);
         return { value: Array.isArray(value) ? value.reverse() : value, lastInsertId };
       }
       case "unique": {
-        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, context);
         if (!Array.isArray(value)) {
           return { value, lastInsertId };
         }
@@ -1589,38 +1577,38 @@ var QueryInterpreter = class _QueryInterpreter {
         return { value: value[0] ?? null, lastInsertId };
       }
       case "required": {
-        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, context);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
         return { value, lastInsertId };
       }
       case "mapField": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.records, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.records, context);
         return { value: mapField2(value, node.args.field), lastInsertId };
       }
       case "join": {
-        const { value: parent, lastInsertId } = await this.interpretNode(node.args.parent, queryable, scope, generators);
+        const { value: parent, lastInsertId } = await this.interpretNode(node.args.parent, context);
         if (parent === null) {
           return { value: null, lastInsertId };
         }
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: (await this.interpretNode(joinExpr.child, queryable, scope, generators)).value
+            childRecords: (await this.interpretNode(joinExpr.child, context)).value
           }))
         );
         return { value: attachChildrenToParents(parent, children), lastInsertId };
       }
       case "transaction": {
-        if (!this.#transactionManager.enabled) {
-          return this.interpretNode(node.args, queryable, scope, generators);
+        if (!context.transactionManager.enabled) {
+          return this.interpretNode(node.args, context);
         }
-        const transactionManager = this.#transactionManager.manager;
+        const transactionManager = context.transactionManager.manager;
         const transactionInfo = await transactionManager.startInternalTransaction();
         const transaction = await transactionManager.getTransaction(transactionInfo, "query");
         try {
-          const value = await this.interpretNode(node.args, transaction, scope, generators);
+          const value = await this.interpretNode(node.args, { ...context, queryable: transaction });
           await transactionManager.commitTransaction(transactionInfo.id);
           return value;
         } catch (e) {
@@ -1629,49 +1617,49 @@ var QueryInterpreter = class _QueryInterpreter {
         }
       }
       case "dataMap": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         return { value: applyDataMap(value, node.args.structure, node.args.enums), lastInsertId };
       }
       case "validate": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         performValidation(value, node.args.rules, node.args);
         return { value, lastInsertId };
       }
       case "if": {
-        const { value } = await this.interpretNode(node.args.value, queryable, scope, generators);
+        const { value } = await this.interpretNode(node.args.value, context);
         if (doesSatisfyRule(value, node.args.rule)) {
-          return await this.interpretNode(node.args.then, queryable, scope, generators);
+          return await this.interpretNode(node.args.then, context);
         } else {
-          return await this.interpretNode(node.args.else, queryable, scope, generators);
+          return await this.interpretNode(node.args.else, context);
         }
       }
       case "unit": {
         return { value: void 0 };
       }
       case "diff": {
-        const { value: from } = await this.interpretNode(node.args.from, queryable, scope, generators);
-        const { value: to } = await this.interpretNode(node.args.to, queryable, scope, generators);
+        const { value: from } = await this.interpretNode(node.args.from, context);
+        const { value: to } = await this.interpretNode(node.args.to, context);
         const keyGetter = (item) => item !== null ? getRecordKey(asRecord(item), node.args.fields) : null;
         const toSet = new Set(asList(to).map(keyGetter));
         return { value: asList(from).filter((item) => !toSet.has(keyGetter(item))) };
       }
       case "process": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         return { value: processRecords(value, node.args.operations), lastInsertId };
       }
       case "initializeRecord": {
-        const { lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { lastInsertId } = await this.interpretNode(node.args.expr, context);
         const record = {};
         for (const [key, initializer] of Object.entries(node.args.fields)) {
-          record[key] = evalFieldInitializer(initializer, lastInsertId, scope, generators);
+          record[key] = evalFieldInitializer(initializer, lastInsertId, context.scope, context.generators);
         }
         return { value: record, lastInsertId };
       }
       case "mapRecord": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
         const record = value === null ? {} : asRecord(value);
         for (const [key, entry] of Object.entries(node.args.fields)) {
-          record[key] = evalFieldOperation(entry, record[key], scope, generators);
+          record[key] = evalFieldOperation(entry, record[key], context.scope, context.generators);
         }
         return { value: record, lastInsertId };
       }
@@ -1716,22 +1704,6 @@ var QueryInterpreter = class _QueryInterpreter {
       onQuery: this.#onQuery
     });
   }
-  #applyComments(query) {
-    if (!this.#sqlCommenter || this.#sqlCommenter.plugins.length === 0) {
-      return query;
-    }
-    const comment = buildSqlComment(this.#sqlCommenter.plugins, {
-      query: this.#sqlCommenter.queryInfo,
-      sql: query.sql
-    });
-    if (!comment) {
-      return query;
-    }
-    return {
-      ...query,
-      sql: appendSqlComment(query.sql, comment)
-    };
-  }
 };
 function isEmpty(value) {
   if (Array.isArray(value)) {
@@ -1832,6 +1804,22 @@ function evalFieldOperation(op, value, scope, generators) {
       assertNever(op, `Unexpected field operation type: ${op["type"]}`);
   }
 }
+function applyComments(query, sqlCommenter) {
+  if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
+    return query;
+  }
+  const comment = buildSqlComment(sqlCommenter.plugins, {
+    query: sqlCommenter.queryInfo,
+    sql: query.sql
+  });
+  if (!comment) {
+    return query;
+  }
+  return {
+    ...query,
+    sql: appendSqlComment(query.sql, comment)
+  };
+}
 
 // src/raw-json-protocol.ts
 import { Decimal as Decimal4 } from "@prisma/client-runtime-utils";

package/dist/interpreter/query-interpreter.d.ts

@@ -13,14 +13,17 @@ export type QueryInterpreterTransactionManager = {
     enabled: false;
 };
 export type QueryInterpreterOptions = {
-    transactionManager: QueryInterpreterTransactionManager;
-    placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
     tracingHelper: TracingHelper;
     serializer: (results: SqlResultSet) => Value;
     rawSerializer?: (results: SqlResultSet) => Value;
     provider?: SchemaProvider;
     connectionInfo?: ConnectionInfo;
+};
+export type QueryRuntimeOptions = {
+    queryable: SqlQueryable;
+    transactionManager: QueryInterpreterTransactionManager;
+    scope: Record<string, unknown>;
     sqlCommenter?: QueryInterpreterSqlCommenter;
 };
 export type QueryInterpreterSqlCommenter = {
@@ -29,16 +32,13 @@ export type QueryInterpreterSqlCommenter = {
 };
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, sqlCommenter, }: QueryInterpreterOptions);
+    constructor({ onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, }: QueryInterpreterOptions);
     static forSql(options: {
-        transactionManager: QueryInterpreterTransactionManager;
-        placeholderValues: Record<string, unknown>;
         onQuery?: (event: QueryEvent) => void;
         tracingHelper: TracingHelper;
         provider?: SchemaProvider;
         connectionInfo?: ConnectionInfo;
-        sqlCommenter?: QueryInterpreterSqlCommenter;
     }): QueryInterpreter;
-    run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
+    run(queryPlan: QueryPlanNode, options: QueryRuntimeOptions): Promise<unknown>;
     private interpretNode;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "7.3.0-dev.14",
+  "version": "7.3.0-dev.16",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,10 +31,10 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/client-runtime-utils": "7.3.0-dev.14",
-    "@prisma/driver-adapter-utils": "7.3.0-dev.14",
-    "@prisma/sqlcommenter": "7.3.0-dev.14",
-    "@prisma/debug": "7.3.0-dev.14"
+    "@prisma/debug": "7.3.0-dev.16",
+    "@prisma/client-runtime-utils": "7.3.0-dev.16",
+    "@prisma/driver-adapter-utils": "7.3.0-dev.16",
+    "@prisma/sqlcommenter": "7.3.0-dev.16"
   },
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",