@prisma/query-plan-executor 7.3.0-dev.14 → 7.3.0-dev.15

package/dist/index.d.ts

@@ -36,12 +36,12 @@ declare class App {
      * Executes a query plan and returns the result.
      *
      * @param queryPlan - The query plan to execute
-     * @param placeholderValues - Placeholder values for the query
+     * @param scope - Placeholder values for the query
      * @param comments - Pre-computed SQL commenter tags from the client
      * @param resourceLimits - Resource limits for the query
      * @param transactionId - Transaction ID if running within a transaction
      */
-    query(queryPlan: QueryPlanNode, placeholderValues: Record<string, unknown>, comments: Record<string, string> | undefined, resourceLimits: ResourceLimits, transactionId: string | null): Promise<unknown>;
+    query(queryPlan: QueryPlanNode, scope: Record<string, unknown>, comments: Record<string, string> | undefined, resourceLimits: ResourceLimits, transactionId: string | null): Promise<unknown>;
     /**
      * Starts a new transaction.
      */

package/dist/index.js

@@ -97773,7 +97773,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "7.3.0-dev.14";
+var version = "7.3.0-dev.15";
 
 // ../../node_modules/.pnpm/temporal-polyfill@0.3.0/node_modules/temporal-polyfill/chunks/internal.js
 function clampProp(e2, n2, t2, o2, r2) {
@@ -107407,8 +107407,6 @@ function getErrorCode2(error44) {
   }
 }
 var QueryInterpreter = class _QueryInterpreter {
-  #transactionManager;
-  #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
   #tracingHelper;
@@ -107416,76 +107414,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((e2) => rethrowAsUserFacing(e2));
+  async run(queryPlan, options) {
+    const { value } = await this.interpretNode(queryPlan, {
+      ...options,
+      generators: this.#generators.snapshot()
+    }).catch((e2) => rethrowAsUserFacing(e2));
     return value;
   }
-  async interpretNode(node, queryable, scope, generators) {
+  async interpretNode(node, context2) {
     switch (node.type) {
       case "value": {
-        return { value: evaluateArg(node.args, scope, generators) };
+        return {
+          value: evaluateArg(node.args, context2.scope, context2.generators)
+        };
       }
       case "seq": {
         let result;
         for (const arg of node.args) {
-          result = await this.interpretNode(arg, queryable, scope, generators);
+          result = await this.interpretNode(arg, context2);
         }
         return result ?? { value: void 0 };
       }
       case "get": {
-        return { value: scope[node.args.name] };
+        return { value: context2.scope[node.args.name] };
       }
       case "let": {
-        const nestedScope = Object.create(scope);
+        const nestedScope = Object.create(context2.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, { ...context2, scope: nestedScope });
           nestedScope[binding.name] = value;
         }
-        return this.interpretNode(node.args.expr, queryable, nestedScope, generators);
+        return this.interpretNode(node.args.expr, { ...context2, scope: nestedScope });
       }
       case "getFirstNonEmpty": {
         for (const name6 of node.args.names) {
-          const value = scope[name6];
+          const value = context2.scope[name6];
           if (!isEmpty(value)) {
             return { value };
           }
@@ -107494,7 +107482,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, context2).then((res) => res.value))
         );
         return {
           value: parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : []
@@ -107502,21 +107490,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, context2).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, context2.scope, context2.generators, this.#maxChunkSize());
         let sum2 = 0;
         for (const query2 of queries) {
-          const commentedQuery = this.#applyComments(query2);
+          const commentedQuery = applyComments(query2, context2.sqlCommenter);
           sum2 += await this.#withQuerySpanAndEvent(
             commentedQuery,
-            queryable,
-            () => queryable.executeRaw(commentedQuery).catch(
+            context2.queryable,
+            () => context2.queryable.executeRaw(commentedQuery).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -107524,14 +107512,14 @@ var QueryInterpreter = class _QueryInterpreter {
         return { value: sum2 };
       }
       case "query": {
-        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        const queries = renderQuery(node.args, context2.scope, context2.generators, this.#maxChunkSize());
         let results;
         for (const query2 of queries) {
-          const commentedQuery = this.#applyComments(query2);
+          const commentedQuery = applyComments(query2, context2.sqlCommenter);
           const result = await this.#withQuerySpanAndEvent(
             commentedQuery,
-            queryable,
-            () => queryable.queryRaw(commentedQuery).catch(
+            context2.queryable,
+            () => context2.queryable.queryRaw(commentedQuery).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -107548,11 +107536,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, context2);
         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, context2);
         if (!Array.isArray(value)) {
           return { value, lastInsertId };
         }
@@ -107562,38 +107550,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, context2);
         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, context2);
         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, context2);
         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, context2)).value
           }))
         );
         return { value: attachChildrenToParents(parent, children), lastInsertId };
       }
       case "transaction": {
-        if (!this.#transactionManager.enabled) {
-          return this.interpretNode(node.args, queryable, scope, generators);
+        if (!context2.transactionManager.enabled) {
+          return this.interpretNode(node.args, context2);
         }
-        const transactionManager = this.#transactionManager.manager;
+        const transactionManager = context2.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, { ...context2, queryable: transaction });
           await transactionManager.commitTransaction(transactionInfo.id);
           return value;
         } catch (e2) {
@@ -107602,49 +107590,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, context2);
         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, context2);
         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, context2);
         if (doesSatisfyRule(value, node.args.rule)) {
-          return await this.interpretNode(node.args.then, queryable, scope, generators);
+          return await this.interpretNode(node.args.then, context2);
         } else {
-          return await this.interpretNode(node.args.else, queryable, scope, generators);
+          return await this.interpretNode(node.args.else, context2);
         }
       }
       case "unit": {
         return { value: void 0 };
       }
       case "diff": {
-        const { value: from } = await this.interpretNode(node.args.from, queryable, scope, generators);
-        const { value: to2 } = await this.interpretNode(node.args.to, queryable, scope, generators);
+        const { value: from } = await this.interpretNode(node.args.from, context2);
+        const { value: to2 } = await this.interpretNode(node.args.to, context2);
         const keyGetter = (item) => item !== null ? getRecordKey(asRecord(item), node.args.fields) : null;
         const toSet = new Set(asList(to2).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, context2);
         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, context2);
         const record2 = {};
         for (const [key, initializer3] of Object.entries(node.args.fields)) {
-          record2[key] = evalFieldInitializer(initializer3, lastInsertId, scope, generators);
+          record2[key] = evalFieldInitializer(initializer3, lastInsertId, context2.scope, context2.generators);
         }
         return { value: record2, lastInsertId };
       }
       case "mapRecord": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, context2);
         const record2 = value === null ? {} : asRecord(value);
         for (const [key, entry] of Object.entries(node.args.fields)) {
-          record2[key] = evalFieldOperation(entry, record2[key], scope, generators);
+          record2[key] = evalFieldOperation(entry, record2[key], context2.scope, context2.generators);
         }
         return { value: record2, lastInsertId };
       }
@@ -107689,22 +107677,6 @@ var QueryInterpreter = class _QueryInterpreter {
       onQuery: this.#onQuery
     });
   }
-  #applyComments(query2) {
-    if (!this.#sqlCommenter || this.#sqlCommenter.plugins.length === 0) {
-      return query2;
-    }
-    const comment = buildSqlComment(this.#sqlCommenter.plugins, {
-      query: this.#sqlCommenter.queryInfo,
-      sql: query2.sql
-    });
-    if (!comment) {
-      return query2;
-    }
-    return {
-      ...query2,
-      sql: appendSqlComment(query2.sql, comment)
-    };
-  }
 };
 function isEmpty(value) {
   if (Array.isArray(value)) {
@@ -107805,6 +107777,22 @@ function evalFieldOperation(op, value, scope, generators) {
       assertNever(op, `Unexpected field operation type: ${op["type"]}`);
   }
 }
+function applyComments(query2, sqlCommenter) {
+  if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
+    return query2;
+  }
+  const comment = buildSqlComment(sqlCommenter.plugins, {
+    query: sqlCommenter.queryInfo,
+    sql: query2.sql
+  });
+  if (!comment) {
+    return query2;
+  }
+  return {
+    ...query2,
+    sql: appendSqlComment(query2.sql, comment)
+  };
+}
 async function getCrypto() {
   return globalThis.crypto ?? await import("node:crypto");
 }
@@ -111984,10 +111972,15 @@ var App = class _App {
   #db;
   #transactionManager;
   #tracingHandler;
+  #interpreter;
   constructor(db, transactionManager, tracingHandler) {
     this.#db = db;
     this.#transactionManager = transactionManager;
     this.#tracingHandler = tracingHandler;
+    this.#interpreter = QueryInterpreter.forSql({
+      tracingHelper: this.#tracingHandler,
+      onQuery: logQuery
+    });
   }
   /**
    * Connects to the database and initializes the application logic.
@@ -112021,12 +112014,12 @@ var App = class _App {
    * Executes a query plan and returns the result.
    *
    * @param queryPlan - The query plan to execute
-   * @param placeholderValues - Placeholder values for the query
+   * @param scope - Placeholder values for the query
    * @param comments - Pre-computed SQL commenter tags from the client
    * @param resourceLimits - Resource limits for the query
    * @param transactionId - Transaction ID if running within a transaction
    */
-  async query(queryPlan, placeholderValues, comments, resourceLimits, transactionId) {
+  async query(queryPlan, scope, comments, resourceLimits, transactionId) {
     const queryable = transactionId !== null ? await this.#transactionManager.getTransaction({ id: transactionId }, "query") : this.#db;
     const sqlCommenter = comments && Object.keys(comments).length > 0 ? {
       plugins: [() => comments],
@@ -112034,15 +112027,13 @@ var App = class _App {
       // query info was already used on the client side to compute the comments
       queryInfo: { type: "single", action: "queryRaw", query: {} }
     } : void 0;
-    const queryInterpreter = QueryInterpreter.forSql({
-      placeholderValues,
-      tracingHelper: this.#tracingHandler,
-      transactionManager: transactionId === null ? { enabled: true, manager: this.#transactionManager } : { enabled: false },
-      onQuery: logQuery,
-      sqlCommenter
-    });
     const result = await Promise.race([
-      queryInterpreter.run(queryPlan, queryable),
+      this.#interpreter.run(queryPlan, {
+        queryable,
+        transactionManager: transactionId === null ? { enabled: true, manager: this.#transactionManager } : { enabled: false },
+        scope,
+        sqlCommenter
+      }),
       import_promises3.default.setTimeout(resourceLimits.queryTimeout.total("milliseconds"), void 0, { ref: false }).then(() => {
         throw new ResourceLimitError("Query timeout exceeded");
       })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/query-plan-executor",
-  "version": "7.3.0-dev.14",
+  "version": "7.3.0-dev.15",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,11 +20,11 @@
     "temporal-polyfill": "0.3.0",
     "vitest": "3.2.4",
     "zod": "4.1.3",
-    "@prisma/adapter-pg": "7.3.0-dev.14",
-    "@prisma/adapter-mariadb": "7.3.0-dev.14",
-    "@prisma/adapter-mssql": "7.3.0-dev.14",
-    "@prisma/driver-adapter-utils": "7.3.0-dev.14",
-    "@prisma/client-engine-runtime": "7.3.0-dev.14"
+    "@prisma/adapter-pg": "7.3.0-dev.15",
+    "@prisma/client-engine-runtime": "7.3.0-dev.15",
+    "@prisma/driver-adapter-utils": "7.3.0-dev.15",
+    "@prisma/adapter-mariadb": "7.3.0-dev.15",
+    "@prisma/adapter-mssql": "7.3.0-dev.15"
   },
   "files": [
     "dist"