@prisma/client-engine-runtime 6.6.0-dev.82 → 6.6.0-dev.84

package/dist/QueryPlan.d.ts

@@ -98,4 +98,7 @@ export type QueryPlanNode = {
         field: string;
         records: QueryPlanNode;
     };
+} | {
+    type: 'transaction';
+    args: QueryPlanNode;
 };

package/dist/index.d.mts

@@ -54,17 +54,24 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ queryable, placeholderValues, onQuery }: QueryInterpreterOptions);
-    run(queryPlan: QueryPlanNode): Promise<unknown>;
+    constructor({ transactionManager, placeholderValues, onQuery }: QueryInterpreterOptions);
+    run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
     private interpretNode;
 }
 
 export declare type QueryInterpreterOptions = {
-    queryable: SqlQueryable;
+    transactionManager: QueryInterpreterTransactionManager;
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
 };
 
+export declare type QueryInterpreterTransactionManager = {
+    enabled: true;
+    manager: TransactionManager;
+} | {
+    enabled: false;
+};
+
 export declare type QueryPlanBinding = {
     name: string;
     expr: QueryPlanNode;
@@ -133,6 +140,9 @@ export declare type QueryPlanNode = {
         field: string;
         records: QueryPlanNode;
     };
+} | {
+    type: 'transaction';
+    args: QueryPlanNode;
 };
 
 export declare type TransactionInfo = {
@@ -143,10 +153,12 @@ export declare class TransactionManager {
     private transactions;
     private closedTransactions;
     private readonly driverAdapter;
-    constructor({ driverAdapter }: {
+    private readonly transactionOptions;
+    constructor({ driverAdapter, transactionOptions }: {
         driverAdapter: SqlDriverAdapter;
+        transactionOptions: TransactionOptions;
     });
-    startTransaction(options: TransactionOptions): Promise<TransactionInfo>;
+    startTransaction(options?: TransactionOptions): Promise<TransactionInfo>;
     commitTransaction(transactionId: string): Promise<void>;
     rollbackTransaction(transactionId: string): Promise<void>;
     getTransaction(txInfo: TransactionInfo, operation: string): Transaction;

package/dist/index.d.ts

@@ -54,17 +54,24 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ queryable, placeholderValues, onQuery }: QueryInterpreterOptions);
-    run(queryPlan: QueryPlanNode): Promise<unknown>;
+    constructor({ transactionManager, placeholderValues, onQuery }: QueryInterpreterOptions);
+    run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
     private interpretNode;
 }
 
 export declare type QueryInterpreterOptions = {
-    queryable: SqlQueryable;
+    transactionManager: QueryInterpreterTransactionManager;
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
 };
 
+export declare type QueryInterpreterTransactionManager = {
+    enabled: true;
+    manager: TransactionManager;
+} | {
+    enabled: false;
+};
+
 export declare type QueryPlanBinding = {
     name: string;
     expr: QueryPlanNode;
@@ -133,6 +140,9 @@ export declare type QueryPlanNode = {
         field: string;
         records: QueryPlanNode;
     };
+} | {
+    type: 'transaction';
+    args: QueryPlanNode;
 };
 
 export declare type TransactionInfo = {
@@ -143,10 +153,12 @@ export declare class TransactionManager {
     private transactions;
     private closedTransactions;
     private readonly driverAdapter;
-    constructor({ driverAdapter }: {
+    private readonly transactionOptions;
+    constructor({ driverAdapter, transactionOptions }: {
         driverAdapter: SqlDriverAdapter;
+        transactionOptions: TransactionOptions;
     });
-    startTransaction(options: TransactionOptions): Promise<TransactionInfo>;
+    startTransaction(options?: TransactionOptions): Promise<TransactionInfo>;
     commitTransaction(transactionId: string): Promise<void>;
     rollbackTransaction(transactionId: string): Promise<void>;
     getTransaction(txInfo: TransactionInfo, operation: string): Transaction;

package/dist/index.js

@@ -274,22 +274,22 @@ function serialize(resultSet) {
 
 // src/interpreter/QueryInterpreter.ts
 var QueryInterpreter = class {
-  #queryable;
+  #transactionManager;
   #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
-  constructor({ queryable, placeholderValues, onQuery }) {
-    this.#queryable = queryable;
+  constructor({ transactionManager, placeholderValues, onQuery }) {
+    this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
   }
-  async run(queryPlan) {
-    return this.interpretNode(queryPlan, this.#placeholderValues, this.#generators.snapshot());
+  async run(queryPlan, queryable) {
+    return this.interpretNode(queryPlan, queryable, this.#placeholderValues, this.#generators.snapshot());
   }
-  async interpretNode(node, scope, generators) {
+  async interpretNode(node, queryable, scope, generators) {
     switch (node.type) {
       case "seq": {
-        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
+        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
         return results[results.length - 1];
       }
       case "get": {
@@ -299,10 +299,10 @@ var QueryInterpreter = class {
         const nestedScope = Object.create(scope);
         await Promise.all(
           node.args.bindings.map(async (binding) => {
-            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope, generators);
+            nestedScope[binding.name] = await this.interpretNode(binding.expr, queryable, scope, generators);
           })
         );
-        return this.interpretNode(node.args.expr, nestedScope, generators);
+        return this.interpretNode(node.args.expr, queryable, nestedScope, generators);
       }
       case "getFirstNonEmpty": {
         for (const name of node.args.names) {
@@ -314,31 +314,31 @@ var QueryInterpreter = class {
         return [];
       }
       case "concat": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
         return parts.reduce((acc, part) => acc.concat(asList(part)), []);
       }
       case "sum": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
         return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
       }
       case "execute": {
         const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
-          return await this.#queryable.executeRaw(query);
+          return await queryable.executeRaw(query);
         });
       }
       case "query": {
         const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
-          return serialize(await this.#queryable.queryRaw(query));
+          return serialize(await queryable.queryRaw(query));
         });
       }
       case "reverse": {
-        const value = await this.interpretNode(node.args, scope, generators);
+        const value = await this.interpretNode(node.args, queryable, scope, generators);
         return Array.isArray(value) ? value.reverse() : value;
       }
       case "unique": {
-        const value = await this.interpretNode(node.args, scope, generators);
+        const value = await this.interpretNode(node.args, queryable, scope, generators);
         if (!Array.isArray(value)) {
           return value;
         }
@@ -348,22 +348,22 @@ var QueryInterpreter = class {
         return value[0] ?? null;
       }
       case "required": {
-        const value = await this.interpretNode(node.args, scope, generators);
+        const value = await this.interpretNode(node.args, queryable, scope, generators);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
         return value;
       }
       case "mapField": {
-        const value = await this.interpretNode(node.args.records, scope, generators);
+        const value = await this.interpretNode(node.args.records, queryable, scope, generators);
         return mapField(value, node.args.field);
       }
       case "join": {
-        const parent = await this.interpretNode(node.args.parent, scope, generators);
+        const parent = await this.interpretNode(node.args.parent, queryable, scope, generators);
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: await this.interpretNode(joinExpr.child, scope, generators)
+            childRecords: await this.interpretNode(joinExpr.child, queryable, scope, generators)
           }))
         );
         if (Array.isArray(parent)) {
@@ -374,6 +374,22 @@ var QueryInterpreter = class {
         }
         return attachChildrenToParent(asRecord(parent), children);
       }
+      case "transaction": {
+        if (!this.#transactionManager.enabled) {
+          return this.interpretNode(node.args, queryable, scope, generators);
+        }
+        const transactionManager = this.#transactionManager.manager;
+        const transactionInfo = await transactionManager.startTransaction();
+        const transaction = transactionManager.getTransaction(transactionInfo, "new");
+        try {
+          const value = await this.interpretNode(node.args, transaction, scope, generators);
+          await transactionManager.commitTransaction(transactionInfo.id);
+          return value;
+        } catch (e) {
+          await transactionManager.rollbackTransaction(transactionInfo.id);
+          throw e;
+        }
+      }
       default: {
         node;
         throw new Error(`Unexpected node type: ${node.type}`);
@@ -528,11 +544,13 @@ var TransactionManager = class {
   // Used to provide better error messages than a generic "transaction not found".
   closedTransactions = [];
   driverAdapter;
-  constructor({ driverAdapter }) {
+  transactionOptions;
+  constructor({ driverAdapter, transactionOptions }) {
     this.driverAdapter = driverAdapter;
+    this.transactionOptions = transactionOptions;
   }
   async startTransaction(options) {
-    const validatedOptions = this.validateOptions(options);
+    const validatedOptions = options !== void 0 ? this.validateOptions(options) : this.transactionOptions;
     const transaction = {
       id: await randomUUID(),
       status: "waiting",

package/dist/index.mjs

@@ -234,22 +234,22 @@ function serialize(resultSet) {
 
 // src/interpreter/QueryInterpreter.ts
 var QueryInterpreter = class {
-  #queryable;
+  #transactionManager;
   #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
-  constructor({ queryable, placeholderValues, onQuery }) {
-    this.#queryable = queryable;
+  constructor({ transactionManager, placeholderValues, onQuery }) {
+    this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
   }
-  async run(queryPlan) {
-    return this.interpretNode(queryPlan, this.#placeholderValues, this.#generators.snapshot());
+  async run(queryPlan, queryable) {
+    return this.interpretNode(queryPlan, queryable, this.#placeholderValues, this.#generators.snapshot());
   }
-  async interpretNode(node, scope, generators) {
+  async interpretNode(node, queryable, scope, generators) {
     switch (node.type) {
       case "seq": {
-        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
+        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
         return results[results.length - 1];
       }
       case "get": {
@@ -259,10 +259,10 @@ var QueryInterpreter = class {
         const nestedScope = Object.create(scope);
         await Promise.all(
           node.args.bindings.map(async (binding) => {
-            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope, generators);
+            nestedScope[binding.name] = await this.interpretNode(binding.expr, queryable, scope, generators);
           })
         );
-        return this.interpretNode(node.args.expr, nestedScope, generators);
+        return this.interpretNode(node.args.expr, queryable, nestedScope, generators);
       }
       case "getFirstNonEmpty": {
         for (const name of node.args.names) {
@@ -274,31 +274,31 @@ var QueryInterpreter = class {
         return [];
       }
       case "concat": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
         return parts.reduce((acc, part) => acc.concat(asList(part)), []);
       }
       case "sum": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
         return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
       }
       case "execute": {
         const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
-          return await this.#queryable.executeRaw(query);
+          return await queryable.executeRaw(query);
         });
       }
       case "query": {
         const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
-          return serialize(await this.#queryable.queryRaw(query));
+          return serialize(await queryable.queryRaw(query));
         });
       }
       case "reverse": {
-        const value = await this.interpretNode(node.args, scope, generators);
+        const value = await this.interpretNode(node.args, queryable, scope, generators);
         return Array.isArray(value) ? value.reverse() : value;
       }
       case "unique": {
-        const value = await this.interpretNode(node.args, scope, generators);
+        const value = await this.interpretNode(node.args, queryable, scope, generators);
         if (!Array.isArray(value)) {
           return value;
         }
@@ -308,22 +308,22 @@ var QueryInterpreter = class {
         return value[0] ?? null;
       }
       case "required": {
-        const value = await this.interpretNode(node.args, scope, generators);
+        const value = await this.interpretNode(node.args, queryable, scope, generators);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
         return value;
       }
       case "mapField": {
-        const value = await this.interpretNode(node.args.records, scope, generators);
+        const value = await this.interpretNode(node.args.records, queryable, scope, generators);
         return mapField(value, node.args.field);
       }
       case "join": {
-        const parent = await this.interpretNode(node.args.parent, scope, generators);
+        const parent = await this.interpretNode(node.args.parent, queryable, scope, generators);
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: await this.interpretNode(joinExpr.child, scope, generators)
+            childRecords: await this.interpretNode(joinExpr.child, queryable, scope, generators)
           }))
         );
         if (Array.isArray(parent)) {
@@ -334,6 +334,22 @@ var QueryInterpreter = class {
         }
         return attachChildrenToParent(asRecord(parent), children);
       }
+      case "transaction": {
+        if (!this.#transactionManager.enabled) {
+          return this.interpretNode(node.args, queryable, scope, generators);
+        }
+        const transactionManager = this.#transactionManager.manager;
+        const transactionInfo = await transactionManager.startTransaction();
+        const transaction = transactionManager.getTransaction(transactionInfo, "new");
+        try {
+          const value = await this.interpretNode(node.args, transaction, scope, generators);
+          await transactionManager.commitTransaction(transactionInfo.id);
+          return value;
+        } catch (e) {
+          await transactionManager.rollbackTransaction(transactionInfo.id);
+          throw e;
+        }
+      }
       default: {
         node;
         throw new Error(`Unexpected node type: ${node.type}`);
@@ -488,11 +504,13 @@ var TransactionManager = class {
   // Used to provide better error messages than a generic "transaction not found".
   closedTransactions = [];
   driverAdapter;
-  constructor({ driverAdapter }) {
+  transactionOptions;
+  constructor({ driverAdapter, transactionOptions }) {
     this.driverAdapter = driverAdapter;
+    this.transactionOptions = transactionOptions;
   }
   async startTransaction(options) {
-    const validatedOptions = this.validateOptions(options);
+    const validatedOptions = options !== void 0 ? this.validateOptions(options) : this.transactionOptions;
     const transaction = {
       id: await randomUUID(),
       status: "waiting",

package/dist/interpreter/QueryInterpreter.d.ts

@@ -1,14 +1,21 @@
 import { SqlQueryable } from '@prisma/driver-adapter-utils';
 import { QueryEvent } from '../events';
 import { QueryPlanNode } from '../QueryPlan';
+import { type TransactionManager } from '../transactionManager/TransactionManager';
+export type QueryInterpreterTransactionManager = {
+    enabled: true;
+    manager: TransactionManager;
+} | {
+    enabled: false;
+};
 export type QueryInterpreterOptions = {
-    queryable: SqlQueryable;
+    transactionManager: QueryInterpreterTransactionManager;
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
 };
 export declare class QueryInterpreter {
     #private;
-    constructor({ queryable, placeholderValues, onQuery }: QueryInterpreterOptions);
-    run(queryPlan: QueryPlanNode): Promise<unknown>;
+    constructor({ transactionManager, placeholderValues, onQuery }: QueryInterpreterOptions);
+    run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
     private interpretNode;
 }

package/dist/transactionManager/TransactionManager.d.ts

@@ -4,10 +4,12 @@ export declare class TransactionManager {
     private transactions;
     private closedTransactions;
     private readonly driverAdapter;
-    constructor({ driverAdapter }: {
+    private readonly transactionOptions;
+    constructor({ driverAdapter, transactionOptions }: {
         driverAdapter: SqlDriverAdapter;
+        transactionOptions: Options;
     });
-    startTransaction(options: Options): Promise<TransactionInfo>;
+    startTransaction(options?: Options): Promise<TransactionInfo>;
     commitTransaction(transactionId: string): Promise<void>;
     rollbackTransaction(transactionId: string): Promise<void>;
     getTransaction(txInfo: TransactionInfo, operation: string): Transaction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "6.6.0-dev.82",
+  "version": "6.6.0-dev.84",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -29,8 +29,8 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/debug": "6.6.0-dev.82",
-    "@prisma/driver-adapter-utils": "6.6.0-dev.82"
+    "@prisma/debug": "6.6.0-dev.84",
+    "@prisma/driver-adapter-utils": "6.6.0-dev.84"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",