OptionalauthorWho authored this change. Recorded on the commit (ICommit.getAuthor).
OptionalautoIf true or set then this will select the affect item after the transaction is complete.
OptionaldescriptionA human description.
OptionalexpectedOptimistic concurrency guard. If set, the operation only begins if the store's current commit id matches; otherwise a TransactionConflictError is thrown.
OptionalmetaStored with the commit (ICommit.getMeta) — for what a view of the history wants to know beyond the description, such as the command that made the change.
OptionaloperationUsed to record audit points.
OptionalpreventIf set to true, prevents further transactions from being pushed onto the stack
until the current transaction is complete. Once the current transaction is either
committed or rolled back, this restriction is automatically lifted.
OptionalreadDeclares the operation read-only: any state update within it throws.
Writes are tracked automatically — a batch that performs no updates never creates a commit (no new commit id, no events, no undo entry) whether or not this is set. The flag is purely an assertion for callers that want the guarantee enforced. Nested transactions inherit it; they cannot opt back out.
Optionalsavepointfalse begins a nested transaction as a step of the one it is nested in: it shares that
one's ITransaction.getSavepointId, so structures the two change in place are the
same copies. For a transaction that wraps one write. A rollback of it alone does not
restore what it changed in place.
OptionalwritesThe records flush writes: a read of one from the store (IStore.getState) flushes first, so a reader never sees them without the held writes.
Only the records the held writes change - a reader of anything else, including the writer itself deciding what to hold, reads as it would. A read made through a transaction (ITransaction.getState) sees that transaction and does not flush.
OptionalflushMake the writes the caller holds for this transaction, into it.
The caller holds writes to make them together; the store calls this whenever something needs them made: before another transaction begins inside this one, before this one commits, and before a read of a record the writes change (writes). A flush writes by beginning transactions inside this one; those do not flush it again.
OptionalonCalled each time a transaction begun directly inside this one commits, while this one is still open.
The transaction that committed. It has closed: what this hook writes begins inside this transaction, and is itself reported here when it commits.
What child, and everything nested in it, recorded with
ITransaction.setIntent, on its own. The operation's intents
(ITransaction.getIntent) hold the union.
For a caller that reacts to each step of an operation as it happens, rather than once when it lands (onCommit). Deeper transactions are part of the step that holds them and are not reported on their own. A child that rolls back is not reported.
OptionalonCalled once the operation this transaction belongs to has landed.
The root's commit. An operation that wrote nothing is elided but still counts as landed.
OptionalonCalled when this transaction, or any transaction it is nested in, rolls back.
Options for operations with the store.