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?