• Public
  • Public/Protected
  • All

This is the entry point for all interactions with Amazon QLDB.

In order to start using the driver, you need to instantiate it with a ledger name:

let qldbDriver: QldbDriver = new QldbDriver(your-ledger-name);

You can pass more parameters to the constructor of the driver which allow you to control certain limits to improve the performance. Check the QldbDriver.constructor to see all the available parameters.

A single instance of the QldbDriver is attached to only one ledger. All transactions will be executed against the ledger specified.

The driver exposes QldbDriver.executeLambda method which should be used to execute the transactions. Check the QldbDriver.executeLambda method for more details on how to execute the Transaction.


  • QldbDriver




  • new QldbDriver(ledgerName: string, qldbClientOptions?: ClientConfiguration, maxConcurrentTransactions?: number, retryConfig?: RetryConfig): QldbDriver
  • Creates a QldbDriver instance that can be used to execute transactions against Amazon QLDB. A single instance of the QldbDriver is always attached to one ledger, as specified in the ledgerName parameter.


    RangeError if maxConcurrentTransactions is less than 0.


    • ledgerName: string

      The name of the ledger you want to connect to. This is a mandatory parameter.

    • Default value qldbClientOptions: ClientConfiguration = {}

      The object containing options for configuring the low level client. See Low Level Client Constructor.

    • Default value maxConcurrentTransactions: number = 0

      The driver internally uses a pool of sessions to execute the transactions. The maxConcurrentTransactions parameter specifies the number of sessions that the driver can hold in the pool. The default is set to maximum number of sockets specified in the globalAgent. See https://docs.aws.amazon.com/qldb/latest/developerguide/driver.best-practices.html#driver.best-practices.configuring for more details.

    • Default value retryConfig: RetryConfig = defaultRetryConfig

      Config to specify max number of retries, base and custom backoff strategy for retries. Will be overridden if a different retryConfig is passed to executeLambda.

    Returns QldbDriver


Private _availablePermits

_availablePermits: number

Private _isClosed

_isClosed: boolean

Private _ledgerName

_ledgerName: string

Private _maxConcurrentTransactions

_maxConcurrentTransactions: number

Private _qldbClient

_qldbClient: QLDBSession

Private _retryConfig

_retryConfig: RetryConfig

Private _semaphore

_semaphore: Semaphore

Private _sessionPool

_sessionPool: QldbSession[]



  • close(): void
  • This is a driver shutdown method which closes all the sessions and marks the driver as closed. Once the driver is closed, no transactions can be executed on that driver instance.

    Note: There is no corresponding open method and the only option is to instantiate another driver.

    Returns void


  • executeLambda<T>(transactionLambda: function, retryConfig?: RetryConfig): Promise<T>
  • This is the primary method to execute a transaction against Amazon QLDB ledger.

    When this method is invoked, the driver will acquire a Transaction and hand it to the TransactionExecutor you passed via the transactionFunction parameter. Once the transactionFunction's execution is done, the driver will try to commit the transaction. If there is a failure along the way, the driver will retry the entire transaction block. This would mean that your code inside the transactionFunction function should be idempotent.

    You can also return the results from the transactionFunction. Here is an example code of executing a transaction

    let result = driver.executeLambda(async (txn:TransactionExecutor) => {
      let a = await txn.execute("SELECT a from Table1");
      let b = await txn.execute("SELECT b from Table2");
      return {a: a, b: b};

    Please keep in mind that the entire transaction will be committed once all the code inside the transactionFunction is executed. So for the above example the values inside the transactionFunction, a and b, are speculative values. If the commit of the transaction fails, the entire transactionFunction will be retried.

    The function passed via retryIndicator parameter is invoked whenever there is a failure and the driver is about to retry the transaction. The retryIndicator will be called with the current attempt number.


    DriverClosedError When a transaction is attempted on a closed driver instance. close


    {@linkcode ClientException} When the commit digest from commit transaction result does not match.


    SessionPoolEmptyError When maxConcurrentTransactions limit is reached and there is no session available in the pool.


    {@linkcode InvalidSessionException} When a session expires either due to a long running transaction or session being idle for long time.


    {@linkcode BadRequestException} When Amazon QLDB is not able to execute a query or transaction.

    Type parameters

    • T


    • transactionLambda: function

      The function representing a transaction to be executed. Please see the method docs to understand the usage of this parameter.

    • Optional retryConfig: RetryConfig

      Config to specify max number of retries, base and custom backoff strategy for retries. This config overrides the retry config set at driver level for a particular lambda execution. Note that all the values of the driver level retry config will be overridden by the new config passed here.

    Returns Promise<T>


  • getTableNames(): Promise<string[]>
  • A helper method to get all the table names in a ledger.

    Returns Promise<string[]>

    Promise which fulfills with an array of table names.

Generated using TypeDoc