@prisma/query-plan-executor 7.10.0-dev.4 → 7.10.0-dev.40

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;