@wpkernel/pipeline v2.0.0

---

@wpkernel/pipeline / CreatePipelineOptions

Interface: CreatePipelineOptions<TInputs, TNodes, TEdges, TEffects, TProjection, TCapabilities, TExtensions, TParticipants, TMiddleware>

Complete configuration captured by createPipeline.

Registration is a one-shot immutable tuple. Extension configuration is copied and frozen before contribution begins; capabilities remain run-local.

Example

import {
  createPipeline,
  runPipeline,
  type GraphDeclaration,
  type NodeContract,
} from '@wpkernel/pipeline';

type Inputs = Readonly<{ source: string }>;
type Nodes = Readonly<{
  uppercase: NodeContract<'source', string, never>;
}>;
type Outputs = Readonly<{ result: 'uppercase' }>;

const declaration: GraphDeclaration<
  Inputs,
  Nodes,
  readonly [],
  Readonly<Record<never, never>>,
  Outputs,
  Readonly<{ locale: string }>
> = {
  inputKeys: ['source'],
  nodes: {
    uppercase: { externalInputs: ['source'], effectKeys: [], priority: 0 },
  },
  edges: [],
  effects: {},
  outputs: { result: 'uppercase' },
  policy: { maxConcurrency: 1 },
  executors: {
    uppercase: ({ input }) => ({
      kind: 'success',
      output: input.external.source.toUpperCase(),
      effects: [],
    }),
  },
};

const pipeline = createPipeline({ declaration, participants: {} });
const outcome = runPipeline({
  pipeline,
  inputs: { source: 'honest dataflow' },
  capabilities: { locale: 'en-SG' },
});

Type Parameters

TInputs

TInputs extends Readonly<Record<string, GraphValue>>

TNodes

TNodes extends NodeRegistry

TEdges

TEdges extends readonly Edge[]

TEffects

TEffects extends EffectRegistry

TProjection

TProjection extends OutputProjection<TNodes>

TCapabilities

TCapabilities

TExtensions

TExtensions extends readonly object[]

TParticipants

TParticipants extends Readonly<Record<PropertyKey, unknown>>

TMiddleware

TMiddleware extends readonly object[]

Properties

declaration

readonly declaration: GraphDeclaration<TInputs, TNodes, TEdges, TEffects, TProjection, TCapabilities>;

---

participants

readonly participants: TParticipants & EffectParticipants<TEffects> & Readonly<Record<Exclude<keyof TParticipants, keyof TEffects>, never>>;

---

extensions?

readonly optional extensions: TExtensions;

Ordered extension tuple. The type checker validates each contribution against the declaration plus every preceding contribution.

---

middleware?

readonly optional middleware: TMiddleware;

Ordered middleware tuple. Each registration is checked against its exact node invocation, output, state and admitted effect requests.

---

observers?

readonly optional observers: readonly RunObserver[];