pqb 0.58.1 → 0.58.2

package/dist/index.mjs

@@ -4576,7 +4576,7 @@ class Transaction {
       return result;
     } else {
       try {
-        sql.text = `SAVEPOINT "${transactionId}"`;
+        sql.text = `SAVEPOINT "t${transactionId}"`;
         if (log) logData = log.beforeQuery(sql);
         const { adapter } = trx;
         await adapter.arrays(sql.text, sql.values);
@@ -4584,13 +4584,13 @@ class Transaction {
         try {
           result = await callback(adapter);
         } catch (err) {
-          sql.text = `ROLLBACK TO SAVEPOINT "${transactionId}"`;
+          sql.text = `ROLLBACK TO SAVEPOINT "t${transactionId}"`;
           if (log) logData = log.beforeQuery(sql);
           await adapter.arrays(sql.text, sql.values);
           if (log) log.afterQuery(sql, logData);
           throw err;
         }
-        sql.text = `RELEASE SAVEPOINT "${transactionId}"`;
+        sql.text = `RELEASE SAVEPOINT "t${transactionId}"`;
         if (log) logData = log.beforeQuery(sql);
         await adapter.arrays(sql.text, sql.values);
         if (log) log.afterQuery(sql, logData);
@@ -4667,6 +4667,58 @@ class Transaction {
       queueMicrotask(hook);
     }
   }
+  /**
+   * Whenever a query in a transaction fails, the transaction is transitioned to a failed state, no further queries are possible.
+   *
+   * Use [catchUniqueError](/guide/error-handling.html#catchuniqueerror) to handle uniqueness errors,
+   * the following examples do not use it to illustrate error handling.
+   *
+   * ```ts
+   * // This transaction is going to fail
+   * db.$transaction(async () => {
+   *   try {
+   *     // imagine it fails because the username is already taken
+   *     await db.user.insert({ username: 'taken' });
+   *   } catch (err) {
+   *     // even though the query is wrapped in a try-catch, the transaction fails anyway
+   *   }
+   * });
+   * ```
+   *
+   * You can use `catch` method on a query instead of `try-catch` to surpass the problem.
+   * The following transaction won't fail:
+   *
+   * ```ts
+   * // Transaction succeeds
+   * db.$transaction(async () => {
+   *   const result = await db.user.insert({ username: 'taken' }).catch(() => 'failed');
+   *
+   *   if (result === 'failed') {
+   *     await db.user.insert({ username: 'another' });
+   *   }
+   * });
+   * ```
+   *
+   * This is because when using `catch` method, `OrchidORM` will wrap the query with a savepoint.
+   *
+   * Alternatively, you can use the `recoverable()` method:
+   *
+   * ```ts
+   * // Transaction succeeds
+   * db.$transaction(async () => {
+   *   try {
+   *     await db.user.insert({ username: 'taken' }).recoverable();
+   *   } catch (err) {
+   *     await db.user.insert({ username: 'another' });
+   *   }
+   * });
+   * ```
+   */
+  recoverable() {
+    const q = _clone(this);
+    q.q.catch = true;
+    return q;
+  }
 }
 const runAfterCommit = (afterCommit, result) => {
   queueMicrotask(async () => {
@@ -4795,7 +4847,7 @@ Object.defineProperty(Then.prototype, "then", {
 });
 function maybeWrappedThen(resolve, reject) {
   const { q } = this;
-  const shouldCatch = q.catch || !!reject;
+  const shouldCatch = q.catch;
   let beforeActionHooks;
   let afterHooks;
   let afterSaveHooks;
@@ -5265,7 +5317,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterSaveHooks, af
   }
 };
 const execQuery = (adapter, method, sql, catchTrx) => {
-  const catchingSavepoint = catchTrx ? String(catchTrx.catchI = (catchTrx.catchI || 0) + 1) : void 0;
+  const catchingSavepoint = catchTrx ? `s${catchTrx.catchI = (catchTrx.catchI || 0) + 1}` : void 0;
   return adapter[method](
     sql.text,
     sql.values,