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

package/dist/index.mjs

@@ -92,6 +92,16 @@ function safeJsonStringify(obj) {
     return val;
   });
 }
+var MAX_PUSH_SPREAD_ARGS = 8192;
+function appendToArray(target, source) {
+  if (source.length <= MAX_PUSH_SPREAD_ARGS) {
+    target.push(...source);
+    return;
+  }
+  for (let i = 0; i < source.length; i += MAX_PUSH_SPREAD_ARGS) {
+    target.push(...source.slice(i, i + MAX_PUSH_SPREAD_ARGS));
+  }
+}
 
 // src/json-protocol.ts
 function normalizeJsonProtocolValues(result) {
@@ -1095,8 +1105,9 @@ function renderTemplateSql(fragments, placeholderFormat, params, argTypes) {
     if (fragment.type === "stringChunk") {
       continue;
     }
-    const length = flattenedParams.length;
-    const added = flattenedParams.push(...flattenedFragmentParams(fragment)) - length;
+    const fragmentParams = Array.from(flattenedFragmentParams(fragment));
+    const added = fragmentParams.length;
+    appendToArray(flattenedParams, fragmentParams);
     if (fragment.argType.arity === "tuple") {
       if (added % fragment.argType.elements.length !== 0) {
         throw new Error(
@@ -1559,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": {
@@ -1579,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) {
@@ -1590,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))
@@ -1645,7 +1654,7 @@ var QueryInterpreter = class _QueryInterpreter {
           if (results === void 0) {
             results = result;
           } else {
-            results.rows.push(...result.rows);
+            appendToArray(results.rows, result.rows);
             results.lastInsertId = result.lastInsertId;
           }
         }
@@ -1725,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);
@@ -1757,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}`);
     }
@@ -1934,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 {};

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

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

package/dist/query-plan.d.ts

@@ -76,12 +76,24 @@ export type JoinExpression = {
     parentField: string;
     isRelationUnique: boolean;
 };
-export type QueryPlanNode = {
+/**
+ * Query plan nodes that are free of side effects and can be interpreted synchronously
+ * without touching the database. The `Rest` parameter controls what other nodes may
+ * appear in child positions: with the default `never` the tree is fully pure, while
+ * `PureQueryPlanNode<ImpureQueryPlanNode>` describes a tree of pure nodes that may
+ * contain impure nodes anywhere inside.
+ */
+export type PureQueryPlanNode<Rest = never> = {
     type: 'value';
     args: PrismaValue;
+    /**
+     * Present when this node is the result of evaluating an impure node during
+     * query plan purification. Never produced by the query compiler.
+     */
+    lastInsertId?: string;
 } | {
     type: 'seq';
-    args: QueryPlanNode[];
+    args: (PureQueryPlanNode<Rest> | Rest)[];
 } | {
     type: 'get';
     args: {
@@ -90,100 +102,118 @@ export type QueryPlanNode = {
 } | {
     type: 'let';
     args: {
-        bindings: QueryPlanBinding[];
-        expr: QueryPlanNode;
+        bindings: {
+            name: string;
+            expr: PureQueryPlanNode<Rest> | Rest;
+        }[];
+        expr: PureQueryPlanNode<Rest> | Rest;
     };
 } | {
     type: 'getFirstNonEmpty';
     args: {
         names: string[];
     };
-} | {
-    type: 'query';
-    args: QueryPlanDbQuery;
-} | {
-    type: 'execute';
-    args: QueryPlanDbQuery;
 } | {
     type: 'reverse';
-    args: QueryPlanNode;
+    args: PureQueryPlanNode<Rest> | Rest;
 } | {
     type: 'sum';
-    args: QueryPlanNode[];
+    args: (PureQueryPlanNode<Rest> | Rest)[];
 } | {
     type: 'concat';
-    args: QueryPlanNode[];
+    args: (PureQueryPlanNode<Rest> | Rest)[];
 } | {
     type: 'unique';
-    args: QueryPlanNode;
+    args: PureQueryPlanNode<Rest> | Rest;
 } | {
     type: 'required';
-    args: QueryPlanNode;
+    args: PureQueryPlanNode<Rest> | Rest;
 } | {
     type: 'join';
     args: {
-        parent: QueryPlanNode;
-        children: JoinExpression[];
+        parent: PureQueryPlanNode<Rest> | Rest;
+        children: {
+            child: PureQueryPlanNode<Rest> | Rest;
+            on: [left: string, right: string][];
+            parentField: string;
+            isRelationUnique: boolean;
+        }[];
         canAssumeStrictEquality: boolean;
     };
 } | {
     type: 'mapField';
     args: {
         field: string;
-        records: QueryPlanNode;
+        records: PureQueryPlanNode<Rest> | Rest;
     };
-} | {
-    type: 'transaction';
-    args: QueryPlanNode;
 } | {
     type: 'dataMap';
     args: {
-        expr: QueryPlanNode;
+        expr: PureQueryPlanNode<Rest> | Rest;
         structure: ResultNode;
         enums: Record<string, Record<string, string>>;
     };
 } | {
     type: 'validate';
     args: {
-        expr: QueryPlanNode;
+        expr: PureQueryPlanNode<Rest> | Rest;
         rules: DataRule[];
     } & ValidationError;
 } | {
     type: 'if';
     args: {
-        value: QueryPlanNode;
+        value: PureQueryPlanNode<Rest> | Rest;
         rule: DataRule;
-        then: QueryPlanNode;
-        else: QueryPlanNode;
+        then: PureQueryPlanNode<Rest> | Rest;
+        else: PureQueryPlanNode<Rest> | Rest;
     };
 } | {
     type: 'unit';
 } | {
     type: 'diff';
     args: {
-        from: QueryPlanNode;
-        to: QueryPlanNode;
+        from: PureQueryPlanNode<Rest> | Rest;
+        to: PureQueryPlanNode<Rest> | Rest;
         fields: string[];
     };
 } | {
     type: 'initializeRecord';
     args: {
-        expr: QueryPlanNode;
+        expr: PureQueryPlanNode<Rest> | Rest;
         fields: Record<string, FieldInitializer>;
     };
 } | {
     type: 'mapRecord';
     args: {
-        expr: QueryPlanNode;
+        expr: PureQueryPlanNode<Rest> | Rest;
         fields: Record<string, FieldOperation>;
     };
 } | {
     type: 'process';
     args: {
-        expr: QueryPlanNode;
+        expr: PureQueryPlanNode<Rest> | Rest;
         operations: InMemoryOps;
     };
 };
+/**
+ * Query plan nodes that perform database I/O: individual queries and statements,
+ * and subtrees executed within a transaction.
+ */
+export type ImpureQueryPlanNode = {
+    type: 'query';
+    args: QueryPlanDbQuery;
+} | {
+    type: 'execute';
+    args: QueryPlanDbQuery;
+} | {
+    type: 'transaction';
+    args: QueryPlanNode;
+};
+/**
+ * A query plan as emitted by the query compiler: a tree of pure nodes that may
+ * contain impure nodes anywhere inside.
+ */
+export type QueryPlanNode = ImpureQueryPlanNode | PureQueryPlanNode<ImpureQueryPlanNode>;
 export type FieldInitializer = {
     type: 'value';
     value: PrismaValue;

package/dist/utils.d.ts

@@ -20,3 +20,8 @@ export declare function doKeysMatch(lhs: {}, rhs: {}): boolean;
  * BigInt and Uint8Array values.
  */
 export declare function safeJsonStringify(obj: unknown): string;
+/**
+ * Appends all elements of `source` to `target` without spreading the whole
+ * array as call arguments, which overflows the stack for large arrays.
+ */
+export declare function appendToArray<T>(target: T[], source: readonly T[]): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "7.10.0-dev.20",
+  "version": "7.10.0-dev.22",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,20 +31,20 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "14.0.0",
-    "@prisma/client-runtime-utils": "7.10.0-dev.20",
-    "@prisma/debug": "7.10.0-dev.20",
-    "@prisma/driver-adapter-utils": "7.10.0-dev.20",
-    "@prisma/sqlcommenter": "7.10.0-dev.20",
-    "@prisma/param-graph": "7.10.0-dev.20",
-    "@prisma/json-protocol": "7.10.0-dev.20"
+    "@prisma/driver-adapter-utils": "7.10.0-dev.22",
+    "@prisma/client-runtime-utils": "7.10.0-dev.22",
+    "@prisma/debug": "7.10.0-dev.22",
+    "@prisma/sqlcommenter": "7.10.0-dev.22",
+    "@prisma/param-graph": "7.10.0-dev.22",
+    "@prisma/json-protocol": "7.10.0-dev.22"
   },
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",
     "@types/benchmark": "2.1.5",
     "@types/node": "~20.19.24",
     "benchmark": "2.1.4",
-    "@prisma/param-graph-builder": "7.10.0-dev.20",
-    "@prisma/get-dmmf": "7.10.0-dev.20"
+    "@prisma/param-graph-builder": "7.10.0-dev.22",
+    "@prisma/get-dmmf": "7.10.0-dev.22"
   },
   "files": [
     "dist"