@prisma/client-engine-runtime 6.15.0-dev.1 → 6.15.0-dev.3

package/dist/index.d.mts

@@ -471,12 +471,8 @@ export declare class TransactionManager {
     startTransaction(options?: TransactionOptions): Promise<TransactionInfo>;
     commitTransaction(transactionId: string): Promise<void>;
     rollbackTransaction(transactionId: string): Promise<void>;
-    getTransaction(txInfo: TransactionInfo, operation: string): Transaction;
-    private getActiveTransaction;
+    getTransaction(txInfo: TransactionInfo, operation: string): Promise<Transaction>;
     cancelAllTransactions(): Promise<void>;
-    private startTransactionTimeout;
-    private closeTransaction;
-    private validateOptions;
 }
 
 export declare class TransactionManagerError extends UserFacingError {

package/dist/index.d.ts

@@ -471,12 +471,8 @@ export declare class TransactionManager {
     startTransaction(options?: TransactionOptions): Promise<TransactionInfo>;
     commitTransaction(transactionId: string): Promise<void>;
     rollbackTransaction(transactionId: string): Promise<void>;
-    getTransaction(txInfo: TransactionInfo, operation: string): Transaction;
-    private getActiveTransaction;
+    getTransaction(txInfo: TransactionInfo, operation: string): Promise<Transaction>;
     cancelAllTransactions(): Promise<void>;
-    private startTransactionTimeout;
-    private closeTransaction;
-    private validateOptions;
 }
 
 export declare class TransactionManagerError extends UserFacingError {

package/dist/index.js

@@ -1618,7 +1618,7 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         const transactionManager = this.#transactionManager.manager;
         const transactionInfo = await transactionManager.startTransaction();
-        const transaction = transactionManager.getTransaction(transactionInfo, "query");
+        const transaction = await transactionManager.getTransaction(transactionInfo, "query");
         try {
           const value = await this.interpretNode(node.args, transaction, scope, generators);
           await transactionManager.commitTransaction(transactionInfo.id);
@@ -1876,11 +1876,6 @@ var TransactionClosedError = class extends TransactionManagerError {
     super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction.`);
   }
 };
-var TransactionClosingError = class extends TransactionManagerError {
-  constructor(operation) {
-    super(`Transaction is being closed: A ${operation} cannot be executed on a closing transaction.`);
-  }
-};
 var TransactionRolledBackError = class extends TransactionManagerError {
   constructor(operation) {
     super(`Transaction already closed: A ${operation} cannot be executed on a transaction that was rolled back.`);
@@ -1953,7 +1948,7 @@ var TransactionManager = class {
     return await this.tracingHelper.runInChildSpan("start_transaction", () => this.#startTransactionImpl(options));
   }
   async #startTransactionImpl(options) {
-    const validatedOptions = options !== void 0 ? this.validateOptions(options) : this.transactionOptions;
+    const validatedOptions = options !== void 0 ? this.#validateOptions(options) : this.transactionOptions;
     const transaction = {
       id: await randomUUID(),
       status: "waiting",
@@ -1970,13 +1965,12 @@ var TransactionManager = class {
     switch (transaction.status) {
       case "waiting":
         if (hasTimedOut) {
-          await this.closeTransaction(transaction, "timed_out");
+          await this.#closeTransaction(transaction, "timed_out");
           throw new TransactionStartTimeoutError();
         }
         transaction.status = "running";
-        transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.timeout);
+        transaction.timer = this.#startTransactionTimeout(transaction.id, validatedOptions.timeout);
         return { id: transaction.id };
-      case "closing":
       case "timed_out":
       case "running":
       case "committed":
@@ -1985,27 +1979,31 @@ var TransactionManager = class {
           `Transaction in invalid state ${transaction.status} although it just finished startup.`
         );
       default:
-        assertNever(transaction.status, "Unknown transaction status.");
+        assertNever(transaction["status"], "Unknown transaction status.");
     }
   }
   async commitTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
-      const txw = this.getActiveTransaction(transactionId, "commit");
-      await this.closeTransaction(txw, "committed");
+      const txw = this.#getActiveOrClosingTransaction(transactionId, "commit");
+      await this.#closeTransaction(txw, "committed");
     });
   }
   async rollbackTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
-      const txw = this.getActiveTransaction(transactionId, "rollback");
-      await this.closeTransaction(txw, "rolled_back");
+      const txw = this.#getActiveOrClosingTransaction(transactionId, "rollback");
+      await this.#closeTransaction(txw, "rolled_back");
     });
   }
-  getTransaction(txInfo, operation) {
-    const tx = this.getActiveTransaction(txInfo.id, operation);
+  async getTransaction(txInfo, operation) {
+    let tx = this.#getActiveOrClosingTransaction(txInfo.id, operation);
+    if (tx.status === "closing") {
+      await tx.closing;
+      tx = this.#getActiveOrClosingTransaction(txInfo.id, operation);
+    }
     if (!tx.transaction) throw new TransactionNotFoundError();
     return tx.transaction;
   }
-  getActiveTransaction(transactionId, operation) {
+  #getActiveOrClosingTransaction(transactionId, operation) {
     const transaction = this.transactions.get(transactionId);
     if (!transaction) {
       const closedTransaction = this.closedTransactions.find((tx) => tx.id === transactionId);
@@ -2031,62 +2029,74 @@ var TransactionManager = class {
         throw new TransactionNotFoundError();
       }
     }
-    if (transaction.status === "closing") {
-      throw new TransactionClosingError(operation);
-    }
     if (["committed", "rolled_back", "timed_out"].includes(transaction.status)) {
       throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.");
     }
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled([...this.transactions.values()].map((tx) => this.closeTransaction(tx, "rolled_back")));
+    await Promise.allSettled([...this.transactions.values()].map((tx) => this.#closeTransaction(tx, "rolled_back")));
   }
-  startTransactionTimeout(transactionId, timeout) {
+  #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     return setTimeout(async () => {
       debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
       const tx = this.transactions.get(transactionId);
       if (tx && ["running", "waiting"].includes(tx.status)) {
-        await this.closeTransaction(tx, "timed_out");
+        await this.#closeTransaction(tx, "timed_out");
       } else {
         debug("Transaction already committed or rolled back when timeout happened.", transactionId);
       }
     }, timeout);
   }
-  async closeTransaction(tx, status) {
-    debug("Closing transaction.", { transactionId: tx.id, status });
-    tx.status = "closing";
-    try {
-      if (tx.transaction && status === "committed") {
-        if (tx.transaction.options.usePhantomQuery) {
-          await this.#withQuerySpanAndEvent(PHANTOM_COMMIT_QUERY(), tx.transaction, () => tx.transaction.commit());
-        } else {
-          const query = COMMIT_QUERY();
-          await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
-          await tx.transaction.commit();
+  async #closeTransaction(tx, status) {
+    const createClosingPromise = async () => {
+      debug("Closing transaction.", { transactionId: tx.id, status });
+      try {
+        if (tx.transaction && status === "committed") {
+          if (tx.transaction.options.usePhantomQuery) {
+            await this.#withQuerySpanAndEvent(PHANTOM_COMMIT_QUERY(), tx.transaction, () => tx.transaction.commit());
+          } else {
+            const query = COMMIT_QUERY();
+            await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
+            await tx.transaction.commit();
+          }
+        } else if (tx.transaction) {
+          if (tx.transaction.options.usePhantomQuery) {
+            await this.#withQuerySpanAndEvent(
+              PHANTOM_ROLLBACK_QUERY(),
+              tx.transaction,
+              () => tx.transaction.rollback()
+            );
+          } else {
+            const query = ROLLBACK_QUERY();
+            await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
+            await tx.transaction.rollback();
+          }
         }
-      } else if (tx.transaction) {
-        if (tx.transaction.options.usePhantomQuery) {
-          await this.#withQuerySpanAndEvent(PHANTOM_ROLLBACK_QUERY(), tx.transaction, () => tx.transaction.rollback());
-        } else {
-          const query = ROLLBACK_QUERY();
-          await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
-          await tx.transaction.rollback();
+      } finally {
+        tx.status = status;
+        clearTimeout(tx.timer);
+        tx.timer = void 0;
+        this.transactions.delete(tx.id);
+        this.closedTransactions.push(tx);
+        if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
+          this.closedTransactions.shift();
         }
       }
-    } finally {
-      tx.status = status;
-      clearTimeout(tx.timer);
-      tx.timer = void 0;
-      this.transactions.delete(tx.id);
-      this.closedTransactions.push(tx);
-      if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
-        this.closedTransactions.shift();
-      }
+    };
+    if (tx.status === "closing") {
+      await tx.closing;
+      this.#getActiveOrClosingTransaction(tx.id, status === "committed" ? "commit" : "rollback");
+    } else {
+      await Object.assign(tx, {
+        status: "closing",
+        reason: status,
+        closing: createClosingPromise()
+      }).closing;
     }
   }
-  validateOptions(options) {
+  #validateOptions(options) {
     if (!options.timeout) throw new TransactionManagerError("timeout is required");
     if (!options.maxWait) throw new TransactionManagerError("maxWait is required");
     if (options.isolationLevel === "SNAPSHOT") throw new InvalidTransactionIsolationLevelError(options.isolationLevel);

package/dist/index.mjs

@@ -1566,7 +1566,7 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         const transactionManager = this.#transactionManager.manager;
         const transactionInfo = await transactionManager.startTransaction();
-        const transaction = transactionManager.getTransaction(transactionInfo, "query");
+        const transaction = await transactionManager.getTransaction(transactionInfo, "query");
         try {
           const value = await this.interpretNode(node.args, transaction, scope, generators);
           await transactionManager.commitTransaction(transactionInfo.id);
@@ -1824,11 +1824,6 @@ var TransactionClosedError = class extends TransactionManagerError {
     super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction.`);
   }
 };
-var TransactionClosingError = class extends TransactionManagerError {
-  constructor(operation) {
-    super(`Transaction is being closed: A ${operation} cannot be executed on a closing transaction.`);
-  }
-};
 var TransactionRolledBackError = class extends TransactionManagerError {
   constructor(operation) {
     super(`Transaction already closed: A ${operation} cannot be executed on a transaction that was rolled back.`);
@@ -1901,7 +1896,7 @@ var TransactionManager = class {
     return await this.tracingHelper.runInChildSpan("start_transaction", () => this.#startTransactionImpl(options));
   }
   async #startTransactionImpl(options) {
-    const validatedOptions = options !== void 0 ? this.validateOptions(options) : this.transactionOptions;
+    const validatedOptions = options !== void 0 ? this.#validateOptions(options) : this.transactionOptions;
     const transaction = {
       id: await randomUUID(),
       status: "waiting",
@@ -1918,13 +1913,12 @@ var TransactionManager = class {
     switch (transaction.status) {
       case "waiting":
         if (hasTimedOut) {
-          await this.closeTransaction(transaction, "timed_out");
+          await this.#closeTransaction(transaction, "timed_out");
           throw new TransactionStartTimeoutError();
         }
         transaction.status = "running";
-        transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.timeout);
+        transaction.timer = this.#startTransactionTimeout(transaction.id, validatedOptions.timeout);
         return { id: transaction.id };
-      case "closing":
       case "timed_out":
       case "running":
       case "committed":
@@ -1933,27 +1927,31 @@ var TransactionManager = class {
           `Transaction in invalid state ${transaction.status} although it just finished startup.`
         );
       default:
-        assertNever(transaction.status, "Unknown transaction status.");
+        assertNever(transaction["status"], "Unknown transaction status.");
     }
   }
   async commitTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
-      const txw = this.getActiveTransaction(transactionId, "commit");
-      await this.closeTransaction(txw, "committed");
+      const txw = this.#getActiveOrClosingTransaction(transactionId, "commit");
+      await this.#closeTransaction(txw, "committed");
     });
   }
   async rollbackTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
-      const txw = this.getActiveTransaction(transactionId, "rollback");
-      await this.closeTransaction(txw, "rolled_back");
+      const txw = this.#getActiveOrClosingTransaction(transactionId, "rollback");
+      await this.#closeTransaction(txw, "rolled_back");
     });
   }
-  getTransaction(txInfo, operation) {
-    const tx = this.getActiveTransaction(txInfo.id, operation);
+  async getTransaction(txInfo, operation) {
+    let tx = this.#getActiveOrClosingTransaction(txInfo.id, operation);
+    if (tx.status === "closing") {
+      await tx.closing;
+      tx = this.#getActiveOrClosingTransaction(txInfo.id, operation);
+    }
     if (!tx.transaction) throw new TransactionNotFoundError();
     return tx.transaction;
   }
-  getActiveTransaction(transactionId, operation) {
+  #getActiveOrClosingTransaction(transactionId, operation) {
     const transaction = this.transactions.get(transactionId);
     if (!transaction) {
       const closedTransaction = this.closedTransactions.find((tx) => tx.id === transactionId);
@@ -1979,62 +1977,74 @@ var TransactionManager = class {
         throw new TransactionNotFoundError();
       }
     }
-    if (transaction.status === "closing") {
-      throw new TransactionClosingError(operation);
-    }
     if (["committed", "rolled_back", "timed_out"].includes(transaction.status)) {
       throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.");
     }
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled([...this.transactions.values()].map((tx) => this.closeTransaction(tx, "rolled_back")));
+    await Promise.allSettled([...this.transactions.values()].map((tx) => this.#closeTransaction(tx, "rolled_back")));
   }
-  startTransactionTimeout(transactionId, timeout) {
+  #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     return setTimeout(async () => {
       debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
       const tx = this.transactions.get(transactionId);
       if (tx && ["running", "waiting"].includes(tx.status)) {
-        await this.closeTransaction(tx, "timed_out");
+        await this.#closeTransaction(tx, "timed_out");
       } else {
         debug("Transaction already committed or rolled back when timeout happened.", transactionId);
       }
     }, timeout);
   }
-  async closeTransaction(tx, status) {
-    debug("Closing transaction.", { transactionId: tx.id, status });
-    tx.status = "closing";
-    try {
-      if (tx.transaction && status === "committed") {
-        if (tx.transaction.options.usePhantomQuery) {
-          await this.#withQuerySpanAndEvent(PHANTOM_COMMIT_QUERY(), tx.transaction, () => tx.transaction.commit());
-        } else {
-          const query = COMMIT_QUERY();
-          await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
-          await tx.transaction.commit();
+  async #closeTransaction(tx, status) {
+    const createClosingPromise = async () => {
+      debug("Closing transaction.", { transactionId: tx.id, status });
+      try {
+        if (tx.transaction && status === "committed") {
+          if (tx.transaction.options.usePhantomQuery) {
+            await this.#withQuerySpanAndEvent(PHANTOM_COMMIT_QUERY(), tx.transaction, () => tx.transaction.commit());
+          } else {
+            const query = COMMIT_QUERY();
+            await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
+            await tx.transaction.commit();
+          }
+        } else if (tx.transaction) {
+          if (tx.transaction.options.usePhantomQuery) {
+            await this.#withQuerySpanAndEvent(
+              PHANTOM_ROLLBACK_QUERY(),
+              tx.transaction,
+              () => tx.transaction.rollback()
+            );
+          } else {
+            const query = ROLLBACK_QUERY();
+            await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
+            await tx.transaction.rollback();
+          }
         }
-      } else if (tx.transaction) {
-        if (tx.transaction.options.usePhantomQuery) {
-          await this.#withQuerySpanAndEvent(PHANTOM_ROLLBACK_QUERY(), tx.transaction, () => tx.transaction.rollback());
-        } else {
-          const query = ROLLBACK_QUERY();
-          await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
-          await tx.transaction.rollback();
+      } finally {
+        tx.status = status;
+        clearTimeout(tx.timer);
+        tx.timer = void 0;
+        this.transactions.delete(tx.id);
+        this.closedTransactions.push(tx);
+        if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
+          this.closedTransactions.shift();
         }
       }
-    } finally {
-      tx.status = status;
-      clearTimeout(tx.timer);
-      tx.timer = void 0;
-      this.transactions.delete(tx.id);
-      this.closedTransactions.push(tx);
-      if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
-        this.closedTransactions.shift();
-      }
+    };
+    if (tx.status === "closing") {
+      await tx.closing;
+      this.#getActiveOrClosingTransaction(tx.id, status === "committed" ? "commit" : "rollback");
+    } else {
+      await Object.assign(tx, {
+        status: "closing",
+        reason: status,
+        closing: createClosingPromise()
+      }).closing;
     }
   }
-  validateOptions(options) {
+  #validateOptions(options) {
     if (!options.timeout) throw new TransactionManagerError("timeout is required");
     if (!options.maxWait) throw new TransactionManagerError("maxWait is required");
     if (options.isolationLevel === "SNAPSHOT") throw new InvalidTransactionIsolationLevelError(options.isolationLevel);

package/dist/transaction-manager/transaction-manager-error.d.ts

@@ -9,9 +9,6 @@ export declare class TransactionNotFoundError extends TransactionManagerError {
 export declare class TransactionClosedError extends TransactionManagerError {
     constructor(operation: string);
 }
-export declare class TransactionClosingError extends TransactionManagerError {
-    constructor(operation: string);
-}
 export declare class TransactionRolledBackError extends TransactionManagerError {
     constructor(operation: string);
 }

package/dist/transaction-manager/transaction-manager.d.ts

@@ -20,10 +20,6 @@ export declare class TransactionManager {
     startTransaction(options?: Options): Promise<TransactionInfo>;
     commitTransaction(transactionId: string): Promise<void>;
     rollbackTransaction(transactionId: string): Promise<void>;
-    getTransaction(txInfo: TransactionInfo, operation: string): Transaction;
-    private getActiveTransaction;
+    getTransaction(txInfo: TransactionInfo, operation: string): Promise<Transaction>;
     cancelAllTransactions(): Promise<void>;
-    private startTransactionTimeout;
-    private closeTransaction;
-    private validateOptions;
 }

package/package.json

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