Interface ITransaction

interface ITransaction {
    depth: number;
    description: string;
    isUndo: boolean;
    uuid: string;
    beginTransaction(description?, onClose?, isUndo?): ITransaction;
    commit(): ITransaction;
    getChangeSet<STATE, INPUTS>(record): ChangeSet<STATE, INPUTS>;
    getState<STATE>(record): STATE;
    parent(): ITransaction;
    rollback(): ITransaction;
    updateState<STATE, INPUTS>(options): ChangeSet<STATE, INPUTS>;
}

Implemented by

TransactionStore

Index

Properties

depth description isUndo uuid

Methods

beginTransaction commit getChangeSet getState parent rollback updateState

Properties

`Readonly` depth

depth: number

`Readonly` description

description: string

`Readonly` isUndo

isUndo: boolean

`Readonly` uuid

uuid: string

unique id for this transaction. This will be the same id for all sub transactions.

Methods

beginTransaction

beginTransaction(description?, onClose?, isUndo?): ITransaction
Begin a transaction with self contained, non-eventing updates
Parameters
- Optional description: string
  The description of the transaction
- Optional onClose: ((transaction) => void)
  A callback for when the transaction is closed (due to either a commit or rollback)
  - - (transaction): void
    - Parameters
      transaction: ITransaction
      Returns void
- Optional isUndo: boolean
  A hint to indicate if the transaction should be support undo.
Returns ITransaction
Remarks
Context is useful for debugging and logging. This is treated as a stack so it's fifo. This means that when finally committed to global changeset that only the final context will be maintained.

commit

commit(): ITransaction
Commit the transaction and all children transactions to the parent changeset.

Returns ITransaction

getChangeSet

getChangeSet<STATE, INPUTS>(record): ChangeSet<STATE, INPUTS>
Type Parameters
- STATE = any
- INPUTS = undefined
Parameters
- record: any
Returns ChangeSet<STATE, INPUTS>

getState

getState<STATE>(record): STATE
Type Parameters
- STATE = any
Parameters
- record: any
Returns STATE

parent

parent(): ITransaction
If root transaction will return self

Returns ITransaction

rollback

rollback(): ITransaction
Discard all changes and children transaction changes.

Returns ITransaction

updateState

updateState<STATE, INPUTS>(options): ChangeSet<STATE, INPUTS>
Type Parameters
- STATE = any
- INPUTS = undefined
Parameters
- options: TransactionalUpdateStateOptions<STATE, INPUTS>
Returns ChangeSet<STATE, INPUTS>