Method RecordTransactionWithBalances

database/transaction.go:211–252

RecordTransactionWithBalances atomically records a transaction and updates both source and destination balances within a single database transaction. This ensures that either all operations succeed together, or none of them are committed, preventing inconsistent ledger states. Parameters: - ctx: Co

(ctx context.Context, txn *model.Transaction, sourceBalance, destinationBalance *model.Balance)

// Returns:
// - The recorded transaction if successful, or an error if any operation fails.
func (d Datasource) RecordTransactionWithBalances(ctx context.Context, txn *model.Transaction, sourceBalance, destinationBalance *model.Balance) (*model.Transaction, error) {
	ctx, span := otel.Tracer("transaction.database").Start(ctx, "RecordTransactionWithBalances")
	defer span.End()

	tx, err := d.Conn.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelDefault})
	if err != nil {
		span.RecordError(err)
		return nil, apierror.NewAPIError(apierror.ErrInternalServer, "Failed to begin transaction", err)
	}

	defer func(tx *sql.Tx) {
		_ = tx.Rollback()
	}(tx)

	if err := updateBalance(ctx, tx, sourceBalance); err != nil {
		span.RecordError(err)
		return nil, err
	}

	if err := updateBalance(ctx, tx, destinationBalance); err != nil {
		span.RecordError(err)
		return nil, err
	}

	if err := recordTransactionInTx(ctx, tx, txn); err != nil {
		span.RecordError(err)
		return nil, err
	}

	if err := tx.Commit(); err != nil {
		span.RecordError(err)
		return nil, apierror.NewAPIError(apierror.ErrInternalServer, "Failed to commit transaction", err)
	}

	span.AddEvent("Transaction and balances recorded atomically", trace.WithAttributes(
		attribute.String("transaction.id", txn.TransactionID),
		attribute.String("source.balance_id", sourceBalance.BalanceID),
		attribute.String("destination.balance_id", destinationBalance.BalanceID),
	))

	return txn, nil
}

// RecordTransactionWithBalancesAndOutbox atomically records a transaction, updates balances,
// and optionally inserts a lineage outbox entry within a single database transaction.