runInTransaction<T extends Object> method

Future<Result<T>> runInTransaction<T extends Object>(
  1. String connectionId,
  2. Future<Result<T>> action(
    1. int txnId
    ), {
  3. IsolationLevel? isolationLevel,
  4. SavepointDialect? savepointDialect,
  5. TransactionAccessMode? accessMode,
  6. Duration? lockTimeout,
})

Runs action inside a freshly opened transaction with automatic commit-on-success / rollback-on-failure semantics.

Implementation

Future<Result<T>> runInTransaction<T extends Object>(
  String connectionId,
  Future<Result<T>> Function(int txnId) action, {
  IsolationLevel? isolationLevel,
  SavepointDialect? savepointDialect,
  TransactionAccessMode? accessMode,
  Duration? lockTimeout,
}) async {
  final beginResult = await beginTransactionWithDefaults(
    connectionId,
    isolationLevel: isolationLevel,
    savepointDialect: savepointDialect,
    accessMode: accessMode,
    lockTimeout: lockTimeout,
  );
  if (beginResult.isError()) {
    return Failure(beginResult.exceptionOrNull()!);
  }
  final txnId = beginResult.getOrNull()!;

  Result<T> userResult;
  try {
    userResult = await action(txnId);
  } on Object catch (e, st) {
    await _safelyRollbackRepository(this, connectionId, txnId);
    return Failure(
      QueryError(
        message: 'runInTransaction: action threw ${e.runtimeType}: $e\n$st',
      ),
    );
  }

  if (userResult.isError()) {
    await _safelyRollbackRepository(this, connectionId, txnId);
    return userResult;
  }

  final commitResult = await commitTransaction(connectionId, txnId);
  if (commitResult.isError()) {
    return Failure(commitResult.exceptionOrNull()!);
  }
  return userResult;
}