`TransactionRollbackError` behavior isn't documented

[MarkSFrancis]

From the transaction docs, it appears that no error will be thrown by calling rollback() on a transaction, but doing so will throw a TransactionRollbackError. Should the docs be updated?

Documented behavior:
The code provided in the docs:

const db = drizzle(...)
await db.transaction(async (tx) => {
  const [account] = await tx.select({ balance: accounts.balance }).from(accounts).where(eq(users.name, 'Dan'));
  if (account.balance < 100) {
    await tx.rollback()
    return
  }
  await tx.update(accounts).set({ balance: sql`${accounts.balance} - 100.00` }).where(eq(users.name, 'Dan'));
  await tx.update(accounts).set({ balance: sql`${accounts.balance} + 100.00` }).where(eq(users.name, 'Andrew'));
});

seems to be misleading, as the await before tx.rollback() is a no-op, and the return underneath will never be called. What will actually happen is that rollback() will throw an error, which is uncaught in this code example.

Actual behavior:

const db = drizzle(...)
await db.transaction(async (tx) => {
  const [account] = await tx.select({ balance: accounts.balance }).from(accounts).where(eq(users.name, 'Dan'));
  if (account.balance < 100) {
    // Throws a `TransactionRollbackError`
    tx.rollback();
  }
  await tx.update(accounts).set({ balance: sql`${accounts.balance} - 100.00` }).where(eq(users.name, 'Dan'));
  await tx.update(accounts).set({ balance: sql`${accounts.balance} + 100.00` }).where(eq(users.name, 'Andrew'));
});

This suggests that throwing was unintentional behavior, but according to this issue in the drizzle-orm repo, it is intentional but undocumented.

[samyarkd]

the docs are broke... this should be merged

[jadengis]

I noticed this as well yesterday and I put up a fix for this here: #315

[hajek-raven]

When trying to use a rollback within a transaction, an exception is thrown. This makes it impossible to return a validation error from within the transaction flow while trying to rollback.

Consider this example:

const db = drizzle(...)
await db.transaction(async (tx) => {
  const [account] = await tx.select({ balance: accounts.balance }).from(accounts).where(eq(users.name, 'Dan'));
  if (account.balance < 100) {
      // This exception is caught by drizzle transaction block and rollback error is rethrown
      throw new TRPCError({
          code: "BAD_REQUEST",
          message: "Balance low"
      });
  }
  await tx.update(accounts).set({ balance: sql`${accounts.balance} - 100.00` }).where(eq(users.name, 'Dan'));
  await tx.update(accounts).set({ balance: sql`${accounts.balance} + 100.00` }).where(eq(users.name, 'Andrew'));
});

[jadengis]

@hajek-raven throwing a normal error will also rollback the transaction so your example above will also work. You don't need to always manually rollback.

[hajek-raven]

@jadengis Yes, but how can I know the reason (original error) from the outside context?

try {
  await db.transaction(async (tx) => {
       throw new TRPCError({
          code: "BAD_REQUEST",
          message: "Wrong recipient"
      });
       
       // ...
       
       throw new TRPCError({
          code: "BAD_REQUEST",
          message: "Balance low"
      });
  });
} catch (e) {
 // e is always rollback error
}

The point is I want to show different messages to the user when different errors occur. But I always get Rollback error.