Transaction

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

Defined in: Core/Transaction.ts:67

An immutable, transactional workflow descriptor coordinating a linear sequence of asynchronous steps with automatic reverse (LIFO) rollback upon failure.

Each step receives the accumulated outputs of all preceding successful steps, and can optionally register an undo action. If any step fails or times out, all previously completed steps are undone in strict reverse order to maintain consistency across external services.

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 checkout = pipe(
  Transaction.make<OrderInput>(),
  Transaction.step({
    id: "reservation",
    run: ({ initial }) => inventoryApi.reserve(initial.sku, initial.qty),
    undo: (res) => inventoryApi.release(res.id),
  }),
  Transaction.step({
    id: "payment",
    run: ({ initial, reservation }) => stripeApi.charge(initial.customerId, reservation.totalCents),
    undo: (pay) => stripeApi.refund(pay.chargeId),
  }),
  Transaction.step({
    id: "shipment",
    run: ({ initial, reservation, payment }) => shippingApi.dispatch(initial.address, reservation.id, payment.chargeId),
  }),
);

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