@prisma/client-engine-runtime 7.10.0-dev.21 → 7.10.0-dev.22

package/dist/index.js

@@ -1623,17 +1623,27 @@ var QueryInterpreter = class _QueryInterpreter {
     });
   }
   async run(queryPlan, options) {
-    const { value } = await this.interpretNode(queryPlan, {
-      ...options,
-      generators: this.#generators.snapshot()
-    }).catch((e) => rethrowAsUserFacing(e));
+    const generators = this.#generators.snapshot();
+    const context = { ...options, generators };
+    const purified = purifyQueryPlan(queryPlan, (node) => this.interpretNode(node, context))?.catch(
+      (e) => rethrowAsUserFacing(e)
+    );
+    if (purified) {
+      try {
+        return this.#interpretPureNode(await purified, context.scope, generators).value;
+      } catch (e) {
+        rethrowAsUserFacing(e);
+      }
+    }
+    const { value } = await this.interpretNode(queryPlan, context).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
   async interpretNode(node, context) {
     switch (node.type) {
       case "value": {
         return {
-          value: evaluateArg(node.args, context.scope, context.generators)
+          value: evaluateArg(node.args, context.scope, context.generators),
+          lastInsertId: node.lastInsertId
         };
       }
       case "seq": {
@@ -1643,9 +1653,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return result ?? { value: void 0 };
       }
-      case "get": {
-        return { value: context.scope[node.args.name] };
-      }
       case "let": {
         const nestedScope = Object.create(context.scope);
         for (const binding of node.args.bindings) {
@@ -1654,15 +1661,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return this.interpretNode(node.args.expr, { ...context, scope: nestedScope });
       }
-      case "getFirstNonEmpty": {
-        for (const name of node.args.names) {
-          const value = context.scope[name];
-          if (!isEmpty(value)) {
-            return { value };
-          }
-        }
-        return { value: [] };
-      }
       case "concat": {
         const parts = await Promise.all(
           node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
@@ -1789,9 +1787,6 @@ var QueryInterpreter = class _QueryInterpreter {
           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, context);
         const { value: to } = await this.interpretNode(node.args.to, context);
@@ -1821,6 +1816,139 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return { value: record, lastInsertId };
       }
+      default:
+        return this.#interpretPureNode(node, context.scope, context.generators);
+    }
+  }
+  #interpretPureNode(node, scope, generators) {
+    switch (node.type) {
+      case "value": {
+        return { value: evaluateArg(node.args, scope, generators), lastInsertId: node.lastInsertId };
+      }
+      case "seq": {
+        let result;
+        for (const arg of node.args) {
+          result = this.#interpretPureNode(arg, scope, generators);
+        }
+        return result ?? { value: void 0 };
+      }
+      case "get": {
+        return { value: scope[node.args.name] };
+      }
+      case "let": {
+        const nestedScope = Object.create(scope);
+        for (const binding of node.args.bindings) {
+          const { value } = this.#interpretPureNode(binding.expr, nestedScope, generators);
+          nestedScope[binding.name] = value;
+        }
+        return this.#interpretPureNode(node.args.expr, nestedScope, generators);
+      }
+      case "getFirstNonEmpty": {
+        for (const name of node.args.names) {
+          const value = scope[name];
+          if (!isEmpty(value)) {
+            return { value };
+          }
+        }
+        return { value: [] };
+      }
+      case "concat": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : []
+        };
+      }
+      case "sum": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => asNumber2(acc) + asNumber2(part)) : 0
+        };
+      }
+      case "reverse": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        return { value: Array.isArray(value) ? value.reverse() : value, lastInsertId };
+      }
+      case "unique": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (!Array.isArray(value)) {
+          return { value, lastInsertId };
+        }
+        if (value.length > 1) {
+          throw new Error(`Expected zero or one element, got ${value.length}`);
+        }
+        return { value: value[0] ?? null, lastInsertId };
+      }
+      case "required": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (isEmpty(value)) {
+          throw new Error("Required value is empty");
+        }
+        return { value, lastInsertId };
+      }
+      case "mapField": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.records, scope, generators);
+        return { value: mapField2(value, node.args.field), lastInsertId };
+      }
+      case "join": {
+        const { value: parent, lastInsertId } = this.#interpretPureNode(node.args.parent, scope, generators);
+        if (parent === null) {
+          return { value: null, lastInsertId };
+        }
+        const children = node.args.children.map((joinExpr) => ({
+          joinExpr,
+          childRecords: this.#interpretPureNode(joinExpr.child, scope, generators).value
+        }));
+        return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
+      }
+      case "dataMap": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        return { value: applyDataMap(value, node.args.structure, node.args.enums), lastInsertId };
+      }
+      case "validate": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        performValidation(value, node.args.rules, node.args);
+        return { value, lastInsertId };
+      }
+      case "if": {
+        const { value } = this.#interpretPureNode(node.args.value, scope, generators);
+        if (doesSatisfyRule(value, node.args.rule)) {
+          return this.#interpretPureNode(node.args.then, scope, generators);
+        } else {
+          return this.#interpretPureNode(node.args.else, scope, generators);
+        }
+      }
+      case "unit": {
+        return { value: void 0 };
+      }
+      case "diff": {
+        const { value: from } = this.#interpretPureNode(node.args.from, scope, generators);
+        const { value: to } = this.#interpretPureNode(node.args.to, scope, generators);
+        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 } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const ops = cloneObject(node.args.operations);
+        evaluateProcessingParameters(ops, scope, generators);
+        return { value: processRecords(value, ops), lastInsertId };
+      }
+      case "initializeRecord": {
+        const { lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = {};
+        for (const [key, initializer] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldInitializer(initializer, lastInsertId, scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
+      case "mapRecord": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = value === null ? {} : asRecord(value);
+        for (const [key, entry] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldOperation(entry, record[key], scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
       default:
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
@@ -1998,6 +2126,112 @@ function evalFieldOperation(op, value, scope, generators) {
       assertNever(op, `Unexpected field operation type: ${op["type"]}`);
   }
 }
+function purifyQueryPlan(node, evalNode) {
+  const impureNode = findUniqueUnconditionalImpureNode(node);
+  if (!impureNode) {
+    return void 0;
+  }
+  return evalNode(impureNode).then((result) => {
+    const evaluated = {
+      type: "value",
+      args: result.value,
+      lastInsertId: result.lastInsertId
+    };
+    const purified = replaceImpureNode(node, impureNode, evaluated);
+    if (!purified) {
+      throw new Error("Could not substitute the evaluated impure node into the query plan");
+    }
+    return purified;
+  });
+}
+function replaceImpureNode(node, target, replacement) {
+  if (node === target) {
+    return replacement;
+  }
+  switch (node.type) {
+    case "seq":
+    case "sum":
+    case "concat": {
+      for (let i = 0; i < node.args.length; i++) {
+        const child = replaceImpureNode(node.args[i], target, replacement);
+        if (child) {
+          return { ...node, args: node.args.map((arg, j) => j === i ? child : arg) };
+        }
+      }
+      return void 0;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process": {
+      const expr = replaceImpureNode(node.args.expr, target, replacement);
+      return expr && { ...node, args: { ...node.args, expr } };
+    }
+    case "mapField": {
+      const records = replaceImpureNode(node.args.records, target, replacement);
+      return records && { ...node, args: { ...node.args, records } };
+    }
+    case "reverse":
+    case "unique":
+    case "required": {
+      const args = replaceImpureNode(node.args, target, replacement);
+      return args && { ...node, args };
+    }
+    default:
+      return void 0;
+  }
+}
+function findUniqueUnconditionalImpureNode(node) {
+  switch (node.type) {
+    case "query":
+    case "execute":
+      return node;
+    case "seq":
+    case "sum":
+    case "concat": {
+      let found = void 0;
+      for (const child of node.args) {
+        const childFound = findUniqueUnconditionalImpureNode(child);
+        if (childFound === null) {
+          return null;
+        }
+        if (childFound) {
+          if (found) {
+            return null;
+          }
+          found = childFound;
+        }
+      }
+      return found;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process":
+      return findUniqueUnconditionalImpureNode(node.args.expr);
+    case "mapField":
+      return findUniqueUnconditionalImpureNode(node.args.records);
+    case "reverse":
+    case "unique":
+    case "required":
+      return findUniqueUnconditionalImpureNode(node.args);
+    case "let":
+    case "join":
+    case "diff":
+    case "if":
+    case "transaction":
+      return null;
+    case "value":
+    case "get":
+    case "getFirstNonEmpty":
+    case "unit":
+      return void 0;
+    default:
+      assertNever(node, `Unexpected node type: ${node.type}`);
+  }
+}
 function applyComments(query, sqlCommenter) {
   if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
     return query;

package/dist/index.mjs

@@ -1570,17 +1570,27 @@ var QueryInterpreter = class _QueryInterpreter {
     });
   }
   async run(queryPlan, options) {
-    const { value } = await this.interpretNode(queryPlan, {
-      ...options,
-      generators: this.#generators.snapshot()
-    }).catch((e) => rethrowAsUserFacing(e));
+    const generators = this.#generators.snapshot();
+    const context = { ...options, generators };
+    const purified = purifyQueryPlan(queryPlan, (node) => this.interpretNode(node, context))?.catch(
+      (e) => rethrowAsUserFacing(e)
+    );
+    if (purified) {
+      try {
+        return this.#interpretPureNode(await purified, context.scope, generators).value;
+      } catch (e) {
+        rethrowAsUserFacing(e);
+      }
+    }
+    const { value } = await this.interpretNode(queryPlan, context).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
   async interpretNode(node, context) {
     switch (node.type) {
       case "value": {
         return {
-          value: evaluateArg(node.args, context.scope, context.generators)
+          value: evaluateArg(node.args, context.scope, context.generators),
+          lastInsertId: node.lastInsertId
         };
       }
       case "seq": {
@@ -1590,9 +1600,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return result ?? { value: void 0 };
       }
-      case "get": {
-        return { value: context.scope[node.args.name] };
-      }
       case "let": {
         const nestedScope = Object.create(context.scope);
         for (const binding of node.args.bindings) {
@@ -1601,15 +1608,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return this.interpretNode(node.args.expr, { ...context, scope: nestedScope });
       }
-      case "getFirstNonEmpty": {
-        for (const name of node.args.names) {
-          const value = context.scope[name];
-          if (!isEmpty(value)) {
-            return { value };
-          }
-        }
-        return { value: [] };
-      }
       case "concat": {
         const parts = await Promise.all(
           node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
@@ -1736,9 +1734,6 @@ var QueryInterpreter = class _QueryInterpreter {
           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, context);
         const { value: to } = await this.interpretNode(node.args.to, context);
@@ -1768,6 +1763,139 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return { value: record, lastInsertId };
       }
+      default:
+        return this.#interpretPureNode(node, context.scope, context.generators);
+    }
+  }
+  #interpretPureNode(node, scope, generators) {
+    switch (node.type) {
+      case "value": {
+        return { value: evaluateArg(node.args, scope, generators), lastInsertId: node.lastInsertId };
+      }
+      case "seq": {
+        let result;
+        for (const arg of node.args) {
+          result = this.#interpretPureNode(arg, scope, generators);
+        }
+        return result ?? { value: void 0 };
+      }
+      case "get": {
+        return { value: scope[node.args.name] };
+      }
+      case "let": {
+        const nestedScope = Object.create(scope);
+        for (const binding of node.args.bindings) {
+          const { value } = this.#interpretPureNode(binding.expr, nestedScope, generators);
+          nestedScope[binding.name] = value;
+        }
+        return this.#interpretPureNode(node.args.expr, nestedScope, generators);
+      }
+      case "getFirstNonEmpty": {
+        for (const name of node.args.names) {
+          const value = scope[name];
+          if (!isEmpty(value)) {
+            return { value };
+          }
+        }
+        return { value: [] };
+      }
+      case "concat": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : []
+        };
+      }
+      case "sum": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => asNumber2(acc) + asNumber2(part)) : 0
+        };
+      }
+      case "reverse": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        return { value: Array.isArray(value) ? value.reverse() : value, lastInsertId };
+      }
+      case "unique": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (!Array.isArray(value)) {
+          return { value, lastInsertId };
+        }
+        if (value.length > 1) {
+          throw new Error(`Expected zero or one element, got ${value.length}`);
+        }
+        return { value: value[0] ?? null, lastInsertId };
+      }
+      case "required": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (isEmpty(value)) {
+          throw new Error("Required value is empty");
+        }
+        return { value, lastInsertId };
+      }
+      case "mapField": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.records, scope, generators);
+        return { value: mapField2(value, node.args.field), lastInsertId };
+      }
+      case "join": {
+        const { value: parent, lastInsertId } = this.#interpretPureNode(node.args.parent, scope, generators);
+        if (parent === null) {
+          return { value: null, lastInsertId };
+        }
+        const children = node.args.children.map((joinExpr) => ({
+          joinExpr,
+          childRecords: this.#interpretPureNode(joinExpr.child, scope, generators).value
+        }));
+        return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
+      }
+      case "dataMap": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        return { value: applyDataMap(value, node.args.structure, node.args.enums), lastInsertId };
+      }
+      case "validate": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        performValidation(value, node.args.rules, node.args);
+        return { value, lastInsertId };
+      }
+      case "if": {
+        const { value } = this.#interpretPureNode(node.args.value, scope, generators);
+        if (doesSatisfyRule(value, node.args.rule)) {
+          return this.#interpretPureNode(node.args.then, scope, generators);
+        } else {
+          return this.#interpretPureNode(node.args.else, scope, generators);
+        }
+      }
+      case "unit": {
+        return { value: void 0 };
+      }
+      case "diff": {
+        const { value: from } = this.#interpretPureNode(node.args.from, scope, generators);
+        const { value: to } = this.#interpretPureNode(node.args.to, scope, generators);
+        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 } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const ops = cloneObject(node.args.operations);
+        evaluateProcessingParameters(ops, scope, generators);
+        return { value: processRecords(value, ops), lastInsertId };
+      }
+      case "initializeRecord": {
+        const { lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = {};
+        for (const [key, initializer] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldInitializer(initializer, lastInsertId, scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
+      case "mapRecord": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = value === null ? {} : asRecord(value);
+        for (const [key, entry] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldOperation(entry, record[key], scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
       default:
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
@@ -1945,6 +2073,112 @@ function evalFieldOperation(op, value, scope, generators) {
       assertNever(op, `Unexpected field operation type: ${op["type"]}`);
   }
 }
+function purifyQueryPlan(node, evalNode) {
+  const impureNode = findUniqueUnconditionalImpureNode(node);
+  if (!impureNode) {
+    return void 0;
+  }
+  return evalNode(impureNode).then((result) => {
+    const evaluated = {
+      type: "value",
+      args: result.value,
+      lastInsertId: result.lastInsertId
+    };
+    const purified = replaceImpureNode(node, impureNode, evaluated);
+    if (!purified) {
+      throw new Error("Could not substitute the evaluated impure node into the query plan");
+    }
+    return purified;
+  });
+}
+function replaceImpureNode(node, target, replacement) {
+  if (node === target) {
+    return replacement;
+  }
+  switch (node.type) {
+    case "seq":
+    case "sum":
+    case "concat": {
+      for (let i = 0; i < node.args.length; i++) {
+        const child = replaceImpureNode(node.args[i], target, replacement);
+        if (child) {
+          return { ...node, args: node.args.map((arg, j) => j === i ? child : arg) };
+        }
+      }
+      return void 0;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process": {
+      const expr = replaceImpureNode(node.args.expr, target, replacement);
+      return expr && { ...node, args: { ...node.args, expr } };
+    }
+    case "mapField": {
+      const records = replaceImpureNode(node.args.records, target, replacement);
+      return records && { ...node, args: { ...node.args, records } };
+    }
+    case "reverse":
+    case "unique":
+    case "required": {
+      const args = replaceImpureNode(node.args, target, replacement);
+      return args && { ...node, args };
+    }
+    default:
+      return void 0;
+  }
+}
+function findUniqueUnconditionalImpureNode(node) {
+  switch (node.type) {
+    case "query":
+    case "execute":
+      return node;
+    case "seq":
+    case "sum":
+    case "concat": {
+      let found = void 0;
+      for (const child of node.args) {
+        const childFound = findUniqueUnconditionalImpureNode(child);
+        if (childFound === null) {
+          return null;
+        }
+        if (childFound) {
+          if (found) {
+            return null;
+          }
+          found = childFound;
+        }
+      }
+      return found;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process":
+      return findUniqueUnconditionalImpureNode(node.args.expr);
+    case "mapField":
+      return findUniqueUnconditionalImpureNode(node.args.records);
+    case "reverse":
+    case "unique":
+    case "required":
+      return findUniqueUnconditionalImpureNode(node.args);
+    case "let":
+    case "join":
+    case "diff":
+    case "if":
+    case "transaction":
+      return null;
+    case "value":
+    case "get":
+    case "getFirstNonEmpty":
+    case "unit":
+      return void 0;
+    default:
+      assertNever(node, `Unexpected node type: ${node.type}`);
+  }
+}
 function applyComments(query, sqlCommenter) {
   if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
     return query;

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

@@ -1,7 +1,7 @@
 import { ConnectionInfo, SqlQueryable, SqlResultSet } from '@prisma/driver-adapter-utils';
 import type { SqlCommenterPlugin, SqlCommenterQueryInfo } from '@prisma/sqlcommenter';
 import { QueryEvent } from '../events';
-import { QueryPlanNode } from '../query-plan';
+import { ImpureQueryPlanNode, PureQueryPlanNode, QueryPlanNode } from '../query-plan';
 import { type SchemaProvider } from '../schema';
 import { type TracingHelper } from '../tracing';
 import { type TransactionManager } from '../transaction-manager/transaction-manager';
@@ -43,3 +43,22 @@ export declare class QueryInterpreter {
     run(queryPlan: DeepReadonly<QueryPlanNode>, options: QueryRuntimeOptions): Promise<unknown>;
     private interpretNode;
 }
+type IntermediateValue = {
+    value: Value;
+    lastInsertId?: string;
+};
+/**
+ * Attempts to convert a query plan into a pure one by finding the single impure node
+ * that is unconditionally evaluated exactly once, evaluating it eagerly via `evalNode`,
+ * and substituting its result into the plan as a constant. The remaining plan can then
+ * be interpreted synchronously.
+ *
+ * Returns `undefined` if the plan cannot be purified this way (it contains no impure
+ * nodes, more than one of them, or unsupported constructs).
+ *
+ * Query plans are cached and shared between requests, so the input plan is never
+ * modified; the returned plan shares all unaffected subtrees with the input and only
+ * copies the nodes on the path to the substituted one.
+ */
+export declare function purifyQueryPlan(node: DeepReadonly<QueryPlanNode>, evalNode: (node: DeepReadonly<ImpureQueryPlanNode>) => Promise<IntermediateValue>): Promise<DeepReadonly<PureQueryPlanNode>> | undefined;
+export {};