pqb 0.58.1 → 0.58.2

package/dist/index.d.ts

@@ -4996,6 +4996,54 @@ declare class Transaction {
      * this will cause `uncaughtException` if the callback is sync and `unhandledRejection` if it is async.
      */
     afterCommit(this: Query, hook: AfterCommitStandaloneHook): void;
+    /**
+     * 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<T>(this: T): T;
 }
 
 type AfterHook<Select extends PropertyKey[], Shape extends Column.QueryColumns> = QueryAfterHook<{

package/dist/index.js

@@ -4578,7 +4578,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);
@@ -4586,13 +4586,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);
@@ -4669,6 +4669,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 () => {
@@ -4797,7 +4849,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;
@@ -5267,7 +5319,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,