@prisma/client-engine-runtime 7.10.0-dev.4 → 7.10.0-dev.41

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

@@ -4,6 +4,16 @@ export type DeepReadonly<T> = T extends undefined | null | boolean | string | nu
 export type DeepUnreadonly<T> = T extends undefined | null | boolean | string | number | symbol | Function | Date ? T : T extends ReadonlyArray<infer U> ? Array<DeepUnreadonly<U>> : unknown extends T ? unknown : {
     -readonly [K in keyof T]: DeepUnreadonly<T[K]>;
 };
+/**
+ * Cross-realm safe check for Uint8Array. `instanceof Uint8Array` fails when the value
+ * was created in a different realm (e.g. jsdom, iframes, vm contexts).
+ */
+export declare function isUint8Array(value: unknown): value is Uint8Array;
+/**
+ * Cross-realm safe check for Date. `instanceof Date` fails when the value
+ * was created in a different realm (e.g. jsdom, iframes, vm contexts).
+ */
+export declare function isDate(value: unknown): value is Date;
 export declare function assertNever(_: never, message: string): never;
 /**
  * Checks if two objects are deeply equal, recursively checking all properties for strict equality.
@@ -20,3 +30,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/dist/utils.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "7.10.0-dev.4",
+  "version": "7.10.0-dev.41",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -26,25 +26,25 @@
   "dependencies": {
     "@bugsnag/cuid": "3.2.1",
     "@opentelemetry/api": "1.9.0",
-    "@paralleldrive/cuid2": "2.2.2",
+    "@paralleldrive/cuid2": "3.3.0",
     "klona": "2.0.6",
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "14.0.0",
-    "@prisma/client-runtime-utils": "7.10.0-dev.4",
-    "@prisma/debug": "7.10.0-dev.4",
-    "@prisma/driver-adapter-utils": "7.10.0-dev.4",
-    "@prisma/sqlcommenter": "7.10.0-dev.4",
-    "@prisma/param-graph": "7.10.0-dev.4",
-    "@prisma/json-protocol": "7.10.0-dev.4"
+    "@prisma/client-runtime-utils": "7.10.0-dev.41",
+    "@prisma/debug": "7.10.0-dev.41",
+    "@prisma/driver-adapter-utils": "7.10.0-dev.41",
+    "@prisma/sqlcommenter": "7.10.0-dev.41",
+    "@prisma/param-graph": "7.10.0-dev.41",
+    "@prisma/json-protocol": "7.10.0-dev.41"
   },
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",
     "@types/benchmark": "2.1.5",
     "@types/node": "~20.19.24",
     "benchmark": "2.1.4",
-    "@prisma/get-dmmf": "7.10.0-dev.4",
-    "@prisma/param-graph-builder": "7.10.0-dev.4"
+    "@prisma/param-graph-builder": "7.10.0-dev.41",
+    "@prisma/get-dmmf": "7.10.0-dev.41"
   },
   "files": [
     "dist"