Transaction

Transaction: object

Defined in: Core/Transaction.ts:52

Type Declaration

make

make: <S>(…steps) => Transaction<CombinedInput<S>, StepOutputs<S>, ErrorOf<S[number]>, UndoErrorOf<S[number]>> = makeTransaction

Assembles step definitions in execution order and validates their dependencies.

Assembles steps in execution order and validates their dependencies.

Type Parameters

S

S extends readonly AnyStepInternal[]

Parameters

steps

…S & (ValidSequence<S, never> extends true ? unknown : never)

Returns

Transaction<CombinedInput<S>, StepOutputs<S>, ErrorOf<S[number]>, UndoErrorOf<S[number]>>

See

Transaction.step for defining reusable steps.

Example

const checkout = Transaction.make(reservation, payment);

run

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

Starts a Transaction and returns a deferred result.

Steps run sequentially. If all steps succeed, returns Ok(Acc) containing all step outputs. If a step returns an error or cancellation is observed before a step starts, completed steps with undo actions are undone in reverse order and the result is Err(Transaction.Failure). Active tasks receive the signal and must handle cancellation themselves.

Call Signature

(): <Acc, E, EUndo>(transaction) => Deferred<Result<Failure<Aborted | E, EUndo>, Acc>>

Starts a Transaction and returns a deferred result.

Steps run sequentially. If all steps succeed, returns Ok(Acc) containing all step outputs. If a step returns an error or cancellation is observed before a step starts, completed steps with undo actions are undone in reverse order and the result is Err(Transaction.Failure). Active tasks receive the signal and must handle cancellation themselves.

Returns

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

See

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

A transaction with no input is run as Transaction.run()(transaction). Pass undefined as the input when such a transaction also needs run options: Transaction.run(undefined, { signal })(transaction).

Example

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

Call Signature

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

Starts a Transaction and returns a deferred result.

Steps run sequentially. If all steps succeed, returns Ok(Acc) containing all step outputs. If a step returns an error or cancellation is observed before a step starts, completed steps with undo actions are undone in reverse order and the result is Err(Transaction.Failure). Active tasks receive the signal and must handle cancellation themselves.

Type Parameters

In

In

Parameters

input

In

options?

RunOptions<unknown, unknown>

Returns

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

See

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

A transaction with no input is run as Transaction.run()(transaction). Pass undefined as the input when such a transaction also needs run options: Transaction.run(undefined, { signal })(transaction).

Example

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

See

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

Example

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

step

step: {<Id, Input, E, Out, EUndo>(id, run, undo?): Step<Id, Input, E, Out, EUndo, Record<never, never>>; <Id, D, Input, E, Out, EUndo>(id, deps, run, undo?): Step<Id, Input, E, Out, EUndo, D>; }

Defines a reusable step with optional named dependencies and compensation.

The step receives its run input in ctx and declared dependency outputs in deps. An optional undo action can reverse external mutations if a later step fails.

Call Signature

<Id, Input, E, Out, EUndo>(id, run, undo?): Step<Id, Input, E, Out, EUndo, Record<never, never>>

Creates a reusable step with optional dependencies and optional compensation.

Type Parameters

Id

Id extends string

Input

Input = void

E

E = never

Out

Out = never

EUndo

EUndo = never

Parameters

id

Id extends "initial" ? never : Id

run

StepRun<Record<never, never>, Input, E, Out>

undo?

StepUndo<Record<never, never>, Input, Out, EUndo>

Returns

Step<Id, Input, E, Out, EUndo, Record<never, never>>

Call Signature

<Id, D, Input, E, Out, EUndo>(id, deps, run, undo?): Step<Id, Input, E, Out, EUndo, D>

Creates a reusable step with optional dependencies and optional compensation.

Type Parameters

Id

Id extends string

D

D extends Record<string, AnyStepInternal | undefined> = Record<never, never>

Input

Input = void

E

E = never

Out

Out = never

EUndo

EUndo = never

Parameters

id

Id extends "initial" ? never : Id

deps

D

run

StepRun<D, Input, E, Out>

undo?

StepUndo<D, Input, Out, EUndo>

Returns

Step<Id, Input, E, Out, EUndo, D>

See

Transaction.run for executing the compiled transaction.

Example

const step = Transaction.stepFactory<OrderInput>();
const reserve = step(
  "inventory",
  ({ ctx }) => reserveInventory(ctx.input.sku),
  ({ ctx }) => releaseInventory(ctx.output.id),
);

stepFactory

stepFactory: <Input>() => StepFactory<Input>

Creates a step constructor with a shared input type.

Type Parameters

Input

Input

Returns

StepFactory<Input>

Example

const step = Transaction.stepFactory<Order>();
const reserve = step("reserve", ({ ctx }) => reserveStock(ctx.input.sku));