@prisma/query-plan-executor 7.10.0-dev.21 → 7.10.0-dev.23

package/dist/index.d.ts

@@ -1645,6 +1645,21 @@ declare interface HTTPResponseError extends Error {
 
 declare type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
 
+/**
+ * Query plan nodes that perform database I/O: individual queries and statements,
+ * and subtrees executed within a transaction.
+ */
+declare type ImpureQueryPlanNode = {
+    type: 'query';
+    args: QueryPlanDbQuery;
+} | {
+    type: 'execute';
+    args: QueryPlanDbQuery;
+} | {
+    type: 'transaction';
+    args: QueryPlanNode;
+};
+
 /**
  * Logs an informational message using the active logger.
  *
@@ -1690,13 +1705,6 @@ declare type IsInvalid<T> = T extends InvalidJSONValue ? true : false;
 
 declare type IsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SNAPSHOT' | 'SERIALIZABLE';
 
-declare type JoinExpression = {
-    child: QueryPlanNode;
-    on: [left: string, right: string][];
-    parentField: string;
-    isRelationUnique: boolean;
-};
-
 declare type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
 
 declare type JSONObject = {
@@ -2403,57 +2411,23 @@ declare type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unk
 declare type Provider = 'mysql' | 'postgres' | 'sqlite' | 'sqlserver';
 
 /**
- * Logs a database query event using the active logger.
- *
- * @param message The message to log
- * @param attributes Optional key-value pairs to include with the log event
- * @throws {Error} if no active logger is found
+ * 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.
  */
-declare function query(message: string, attributes?: ExtendedAttributes): void;
-
-declare interface Queryable<Query, Result> extends AdapterInfo {
-    /**
-     * Execute a query and return its result.
-     */
-    queryRaw(params: Query): Promise<Result>;
-    /**
-     * Execute a query and return the number of affected rows.
-     */
-    executeRaw(params: Query): Promise<number>;
-}
-
-declare type QueryEvent = {
-    timestamp: Date;
-    query: string;
-    params: readonly unknown[];
-    duration: number;
-};
-
-declare type QueryPlanBinding = {
-    name: string;
-    expr: QueryPlanNode;
-};
-
-declare type QueryPlanDbQuery = {
-    type: 'rawSql';
-    sql: string;
-    args: PrismaValue[];
-    argTypes: ArgType[];
-} | {
-    type: 'templateSql';
-    fragments: Fragment[];
-    placeholderFormat: PlaceholderFormat;
-    args: PrismaValue[];
-    argTypes: DynamicArgType[];
-    chunkable: boolean;
-};
-
-declare type QueryPlanNode = {
+declare 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: {
@@ -2462,101 +2436,147 @@ declare 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;
     };
 };
 
+/**
+ * Logs a database query event using the active logger.
+ *
+ * @param message The message to log
+ * @param attributes Optional key-value pairs to include with the log event
+ * @throws {Error} if no active logger is found
+ */
+declare function query(message: string, attributes?: ExtendedAttributes): void;
+
+declare interface Queryable<Query, Result> extends AdapterInfo {
+    /**
+     * Execute a query and return its result.
+     */
+    queryRaw(params: Query): Promise<Result>;
+    /**
+     * Execute a query and return the number of affected rows.
+     */
+    executeRaw(params: Query): Promise<number>;
+}
+
+declare type QueryEvent = {
+    timestamp: Date;
+    query: string;
+    params: readonly unknown[];
+    duration: number;
+};
+
+declare type QueryPlanDbQuery = {
+    type: 'rawSql';
+    sql: string;
+    args: PrismaValue[];
+    argTypes: ArgType[];
+} | {
+    type: 'templateSql';
+    fragments: Fragment[];
+    placeholderFormat: PlaceholderFormat;
+    args: PrismaValue[];
+    argTypes: DynamicArgType[];
+    chunkable: boolean;
+};
+
+/**
+ * A query plan as emitted by the query compiler: a tree of pure nodes that may
+ * contain impure nodes anywhere inside.
+ */
+declare type QueryPlanNode = ImpureQueryPlanNode | PureQueryPlanNode<ImpureQueryPlanNode>;
+
 declare type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
 
 declare type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? (K extends string ? T : never) : never;

package/dist/index.js

@@ -93473,7 +93473,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "7.10.0-dev.21";
+var version = "7.10.0-dev.23";
 
 // ../../node_modules/.pnpm/temporal-polyfill@0.3.0/node_modules/temporal-polyfill/chunks/internal.js
 function clampProp(e2, n2, t2, o2, r2) {
@@ -103126,17 +103126,27 @@ var QueryInterpreter = class _QueryInterpreter {
     });
   }
   async run(queryPlan, options) {
-    const { value } = await this.interpretNode(queryPlan, {
-      ...options,
-      generators: this.#generators.snapshot()
-    }).catch((e2) => rethrowAsUserFacing(e2));
+    const generators = this.#generators.snapshot();
+    const context4 = { ...options, generators };
+    const purified = purifyQueryPlan(queryPlan, (node) => this.interpretNode(node, context4))?.catch(
+      (e2) => rethrowAsUserFacing(e2)
+    );
+    if (purified) {
+      try {
+        return this.#interpretPureNode(await purified, context4.scope, generators).value;
+      } catch (e2) {
+        rethrowAsUserFacing(e2);
+      }
+    }
+    const { value } = await this.interpretNode(queryPlan, context4).catch((e2) => rethrowAsUserFacing(e2));
     return value;
   }
   async interpretNode(node, context4) {
     switch (node.type) {
       case "value": {
         return {
-          value: evaluateArg(node.args, context4.scope, context4.generators)
+          value: evaluateArg(node.args, context4.scope, context4.generators),
+          lastInsertId: node.lastInsertId
         };
       }
       case "seq": {
@@ -103146,9 +103156,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return result ?? { value: void 0 };
       }
-      case "get": {
-        return { value: context4.scope[node.args.name] };
-      }
       case "let": {
         const nestedScope = Object.create(context4.scope);
         for (const binding of node.args.bindings) {
@@ -103157,15 +103164,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return this.interpretNode(node.args.expr, { ...context4, scope: nestedScope });
       }
-      case "getFirstNonEmpty": {
-        for (const name6 of node.args.names) {
-          const value = context4.scope[name6];
-          if (!isEmpty(value)) {
-            return { value };
-          }
-        }
-        return { value: [] };
-      }
       case "concat": {
         const parts = await Promise.all(
           node.args.map((arg) => this.interpretNode(arg, context4).then((res) => res.value))
@@ -103292,9 +103290,6 @@ var QueryInterpreter = class _QueryInterpreter {
           return await this.interpretNode(node.args.else, context4);
         }
       }
-      case "unit": {
-        return { value: void 0 };
-      }
       case "diff": {
         const { value: from } = await this.interpretNode(node.args.from, context4);
         const { value: to2 } = await this.interpretNode(node.args.to, context4);
@@ -103324,6 +103319,139 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return { value: record2, lastInsertId };
       }
+      default:
+        return this.#interpretPureNode(node, context4.scope, context4.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 name6 of node.args.names) {
+          const value = scope[name6];
+          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: to2 } = this.#interpretPureNode(node.args.to, scope, generators);
+        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 } = 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 record2 = {};
+        for (const [key, initializer3] of Object.entries(node.args.fields)) {
+          record2[key] = evalFieldInitializer(initializer3, lastInsertId, scope, generators);
+        }
+        return { value: record2, lastInsertId };
+      }
+      case "mapRecord": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record2 = value === null ? {} : asRecord(value);
+        for (const [key, entry] of Object.entries(node.args.fields)) {
+          record2[key] = evalFieldOperation(entry, record2[key], scope, generators);
+        }
+        return { value: record2, lastInsertId };
+      }
       default:
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
@@ -103501,6 +103629,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 i2 = 0; i2 < node.args.length; i2++) {
+        const child = replaceImpureNode(node.args[i2], target, replacement);
+        if (child) {
+          return { ...node, args: node.args.map((arg, j2) => j2 === i2 ? 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(query2, sqlCommenter) {
   if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
     return query2;
@@ -108164,10 +108398,18 @@ function mapDriverError3(error44) {
         message: error44.message
       };
     case "23505": {
-      const fields = error44.detail?.match(/Key \(([^)]+)\)/)?.at(1)?.split(", ");
+      let constraint;
+      if (error44.constraint) {
+        constraint = { index: error44.constraint };
+      } else {
+        const fields = error44.detail?.match(/Key \(([^)]+)\)/)?.at(1)?.split(", ");
+        if (fields !== void 0) {
+          constraint = { fields };
+        }
+      }
       return {
         kind: "UniqueConstraintViolation",
-        constraint: fields !== void 0 ? { fields } : void 0
+        constraint
       };
     }
     case "23502": {

package/package.json

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