When does beforeRetry run?

[abegehr]

beforeRetry runs in loadPendingTransactions():

db/packages/offline-transactions/src/executor/TransactionExecutor.ts

Lines 228 to 257 in be656be

	async loadPendingTransactions(): Promise<void> {
	const transactions = await this.outbox.getAll()
	let filteredTransactions = transactions
	if (this.config.beforeRetry) {
	filteredTransactions = this.config.beforeRetry(transactions)
	}
	for (const transaction of filteredTransactions) {
	this.scheduler.schedule(transaction)
	}
	// Restore optimistic state for loaded transactions
	// This ensures the UI shows the optimistic data while transactions are pending
	this.restoreOptimisticState(filteredTransactions)
	// Reset retry delays for all loaded transactions so they can run immediately
	this.resetRetryDelays()
	// Schedule retry timer for loaded transactions
	this.scheduleNextRetry()
	const removedTransactions = transactions.filter(
	(tx) => !filteredTransactions.some((filtered) => filtered.id === tx.id),
	)
	if (removedTransactions.length > 0) {
	await this.outbox.removeMany(removedTransactions.map((tx) => tx.id))
	}
	}

However, it is not called in handleError when scheduling a retry:

db/packages/offline-transactions/src/executor/TransactionExecutor.ts

Lines 159 to 226 in be656be

	private async handleError(
	transaction: OfflineTransaction,
	error: Error,
	): Promise<void> {
	return withNestedSpan(
	`transaction.handleError`,
	{
	'transaction.id': transaction.id,
	'error.name': error.name,
	'error.message': error.message,
	},
	async (span) => {
	const shouldRetry = this.retryPolicy.shouldRetry(
	error,
	transaction.retryCount,
	)
	span.setAttribute(`shouldRetry`, shouldRetry)
	if (!shouldRetry) {
	this.scheduler.markCompleted(transaction)
	await this.outbox.remove(transaction.id)
	console.warn(
	`Transaction ${transaction.id} failed permanently:`,
	error,
	)
	span.setAttribute(`result`, `permanent_failure`)
	// Signal permanent failure to the waiting transaction
	this.offlineExecutor.rejectTransaction(transaction.id, error)
	return
	}
	const delay = Math.max(
	0,
	this.retryPolicy.calculateDelay(transaction.retryCount),
	)
	const updatedTransaction: OfflineTransaction = {
	...transaction,
	retryCount: transaction.retryCount + 1,
	nextAttemptAt: Date.now() + delay,
	lastError: {
	name: error.name,
	message: error.message,
	stack: error.stack,
	},
	}
	span.setAttribute(`retryDelay`, delay)
	span.setAttribute(`nextRetryCount`, updatedTransaction.retryCount)
	this.scheduler.markFailed(transaction)
	this.scheduler.updateTransaction(updatedTransaction)
	try {
	await this.outbox.update(transaction.id, updatedTransaction)
	span.setAttribute(`result`, `scheduled_retry`)
	} catch (persistError) {
	span.recordException(persistError as Error)
	span.setAttribute(`result`, `persist_failed`)
	throw persistError
	}
	// Schedule retry timer
	this.scheduleNextRetry()
	},
	)
	}

I would have assumed beforeRetry() would run every time before a transaction is retried. Is this not the case?

[barry166]

From the current code, your reading is right: beforeRetry is not called before every retry attempt. It runs when persisted pending transactions are loaded from the outbox, before they are put back into the retry scheduler.

So it is more like filterPendingTransactionsBeforeRestoring() than a per-attempt hook. Once a transaction is already scheduled and then fails, handleError() uses the retry policy to decide delay/count and writes the updated transaction back to the outbox without calling beforeRetry again.

If you need per-attempt gating, that probably needs a separate hook in handleError() / before scheduling the next retry, not just beforeRetry as it exists now.