Transaction

Transaction<In, Acc, E, EUndo> = WithKind<"Transaction"> & object

Defined in: Core/Transaction.ts:52

A reusable sequence of asynchronous steps with optional actions to undo completed work.

If a step returns an error, completed steps that have an undo action are undone in reverse order. Undo actions can also fail; their errors are returned alongside the original error.

Type Parameters

In

In = void

The initial input payload supplied to the transaction on execution.

Acc

Acc extends Record<string, unknown> = Record<never, never>

The accumulated dictionary of step outputs available to downstream steps.

E

E = never

The union of forward execution error types across all registered steps.

EUndo

EUndo = never

The union of error types that can occur during compensating undo actions.

Type Declaration

[_transactionBrand]

readonly [_transactionBrand]: object

[_transactionBrand]._acc

readonly _acc: () => Acc

Returns

Acc

[_transactionBrand]._error

readonly _error: () => E

Returns

E

[_transactionBrand]._in

readonly _in: (_in) => void

Parameters

_in

In

Returns

void

[_transactionBrand]._undoError

readonly _undoError: () => EUndo

Returns

EUndo

Example

const step = Transaction.stepFactory<OrderInput>();
const reservation = step(
  "reservation",
  ({ ctx }) => inventoryApi.reserve(ctx.input.sku, ctx.input.qty),
  ({ ctx }) => inventoryApi.release(ctx.output.id),
);
const payment = step(
  "payment",
  { reservation },
  ({ ctx, deps }) => stripeApi.charge(ctx.input.customerId, deps.reservation.totalCents),
  ({ ctx }) => stripeApi.refund(ctx.output.chargeId),
);
const checkout = Transaction.make(reservation, payment);

const outcome = await Transaction.run(orderInput)(checkout);