Transaction

Transaction: object

Defined in: Core/Transaction.ts:67

Type Declaration

make

make: <In>() => Transaction<In, Record<never, never>, never, never> = makeTransaction

Creates an empty, initialized Transaction ready to accumulate steps.

Creates an empty, initialized Transaction ready to accumulate steps.

Type Parameters

In

In = void

The initial payload supplied to Transaction.run. Defaults to void.

Returns

Transaction<In, Record<never, never>, never, never>

See

Transaction.step for appending sequential steps to the transaction.

Example

// Zero-argument transaction:
const pingTransaction = Transaction.make();

// Parameterized transaction:
const orderTransaction = Transaction.make<OrderInput>();

See

Transaction.step for appending sequential steps to the transaction.

Example

const checkout = Transaction.make<OrderInput>();

run

run: {(options?): <Acc, E, EUndo>(transaction) => Result<Failure<E, EUndo>, Acc>; <In>(input, options?): <Acc, E, EUndo>(transaction) => Result<Failure<E, EUndo>, Acc>; } = runTransaction

Executes a Transaction, returning an infallible lazy Task.Result.

Steps run sequentially. If all steps succeed, returns Ok(Acc) containing all step outputs. If any step fails, times out, or is aborted, completed steps are undone in reverse (LIFO) order and returns Err(Transaction.Failure).

Call Signature

(options?): <Acc, E, EUndo>(transaction) => Result<Failure<E, EUndo>, Acc>

Executes a zero-input Transaction with optional run options.

Parameters

options?

RunOptions<unknown, unknown>

Returns

<Acc, E, EUndo>(transaction) => Result<Failure<E, EUndo>, Acc>

Call Signature

<In>(input, options?): <Acc, E, EUndo>(transaction) => Result<Failure<E, EUndo>, Acc>

Executes a parameterized Transaction with input and optional run options.

Type Parameters

In

In

Parameters

input

In

options?

RunOptions<unknown, unknown>

Returns

<Acc, E, EUndo>(transaction) => Result<Failure<E, EUndo>, Acc>

See

Transaction.step for configuring transactional steps with compensating undo actions.

Example

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

step

step: <In, Acc, Id, Out, E2, EUndo2, ETimeout>(config) => <E1, EUndo1>(transaction) => Transaction<In, Acc & { readonly [K in string]: Out }, E2 | ETimeout | E1, EUndo2 | EUndo1>

Appends a step to a Transaction with an optional compensating undo action.

The step receives an accumulated context containing the initial input and all outputs from preceding steps. An optional compensating undo action can be defined to reverse external mutations if this or any subsequent step fails.

Appends a step to a Transaction.

The step receives an accumulated context containing the initial input and all outputs from preceding steps. An optional compensating undo action can be defined to reverse any external mutations if this or any subsequent step fails.

Supports optional retry and timeout resilience policies on forward execution.

Type Parameters

In

In = void

Acc

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

Id

Id extends string = string

Out

Out = unknown

E2

E2 = never

EUndo2

EUndo2 = never

ETimeout

ETimeout = never

Parameters

config

StepConfig<In, Acc, Id, Out, E2, EUndo2, ETimeout>

Returns

<E1, EUndo1>(transaction) => Transaction<In, Acc & { readonly [K in string]: Out }, E2 | ETimeout | E1, EUndo2 | EUndo1>

See

Transaction.run for executing the compiled transaction.

Example

const transaction = pipe(
  Transaction.make<OrderInput>(),
  Transaction.step({
    id: "inventory",
    run: ({ initial }) => reserveInventory(initial.sku),
    undo: (reservation) => releaseInventory(reservation.id),
  }),
);

See

Transaction.run for executing the compiled transaction.

Example

const withStep = pipe(
  transaction,
  Transaction.step({
    id: "inventory",
    run: ({ initial }) => reserveInventory(initial.sku),
    undo: (res) => releaseInventory(res.id),
  }),
);