Correct way to check if session is a transaction?

[rubenferreira97]

Use case:
I am trying to implement a manual run-time "@Transactional" on the service layer. For this I need to check if a session is running in a transaction level. Look at the following POC:

extension on SessionExecutor {
  // This function runs a query block transactionaly. It creates a `TxSession` only if session is not a transaction.
  Future<T> transaction<T>(
    Future<T> Function(TxSession txSession) queryBlock, {
    Session? session,
    TransactionSettings? settings,
  }) {
    return switch (session) {
      TxSession() => queryBlock(session), // ➡️ Can I assume all transactions sessions are `TxSession`s❓
      _ => runTx(queryBlock, settings: settings),
    };
  }
}

class Service {
  Service({required this.executor});

  final SessionExecutor executor;

  Future<void> transaction1(TxSession? txSession) async {
    // if txSession is not null create a transaction and run, else run  in the given transaction session
    await executor.transaction(session: txSession, (session) async {
      await session.execute(...); // Task 1
    });
  }

  Future<void> transaction2(TxSession? txSession) async {
    // if txSession is not null create a transaction and run, else run in the given transaction session
    await executor.transaction(session: txSession, (session) async {
      await session.execute(...); // Task 2
    });
  }

  Future<void> transaction1and2(TxSession? txSession) async {
    // if txSession is not null create a transaction and run, else run in the given transaction session
    await executor.transaction(session: txSession, (session) async {
      await transaction1(session);
      await transaction2(session);
      await session.execute(...); // Task 3
    });
  }
}

I am relying that this holds true for all transactions:

final isTransaction = session is TxSession;

However this might be a problem in the future if this library creates something like TxSession2 (which seems a silly example).
To fix this issue some libraries expose a field like:

abstract Session {
  bool get isTransaction;
}

How should I check if a session is a transaction? Can I rely on is TxSession?

[isoos]

How should I check if a session is a transaction? Can I rely on is TxSession?

Right now: yes. It is unlikely that it will change anytime soon.

I'm curious though: why this pattern? Is there something that we should rather do at the package level that may serve you better?

[rubenferreira97]

Thanks for the input! I think this shouldn't be solved at the package level (at least in core) other than being able to check if a session is in a transaction context. The idea of this pattern is to avoid complex managers like a TransactionManager available on multiple frameworks and still allow "Transaction Propagation". By other words, this pattern allows to run a unit of work as standalone or multiple unit of works as one, also share business logic across methods and rollback changes in case of one of these units fail.

Example:

class BankService {
  BankService({required this.executor});

  final SessionExecutor executor;

  Future<double> getBalance(int id, TxSession? txSession) {
    return executor.transaction(session: txSession, (session) async {
      final rows = await session.execute('SELECT balance FROM account WHERE id=@id', parameters {'id': id});
      final balance = rows[0][0];
      if(balance < 0) throw ...; // random business logic, this makes no sense tho 😁
      return balance;
    });
  }

  Future<double> updateBalance(int id, double amount, TxSession? txSession) async {
    return executor.transaction(session: txSession, (session) async {
      final balance = await getBalance(id, session); // Transaction propagation
      final newBalance = balance + amount;
      if(newBalance < 0) throw...; // some business logic
      await session.execute('UPDATE account SET balance = @balance WHERE id=@id;', parameters {'id': id, 'balance': newBalance});
      return newAmount;
    });
  }
}

// we can use getBalance alone or updateBalance
final balance = getBalance(1);
final newAmount = updateBalance(1, 100);

[isoos]

How is this different from a request-level variable (be it zone-local or at the request object) that stores a lazily initialized Future<TxSession>? I don't think one should need more complexity than that (the indirection and parameter passing with the executor.transaction is not my favorite pattern here).