@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/orchestration/contracts/vocabulary.js

@@ -0,0 +1,30 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+export const TransitionTargetKind = defineClosedVocabulary({
+    Stage: 'stage',
+    Complete: 'complete',
+    AwaitSignal: 'await-signal',
+});
+export const WorkflowStatus = defineClosedVocabulary({
+    Active: 'active',
+    Waiting: 'waiting',
+    Completed: 'completed',
+    Blocked: 'blocked',
+    Superseded: 'superseded',
+});
+export const ActivityActivationStatus = defineClosedVocabulary({
+    Pending: 'pending',
+    Running: 'running',
+    Waiting: 'waiting',
+    Completed: 'completed',
+});
+export const WorkflowInstanceKind = defineClosedVocabulary({
+    Primary: 'primary',
+    Child: 'child',
+});
+// Who may satisfy a wait. Distinct from EventActorKind: that vocabulary answers
+// who emitted an event (provenance); this answers who may open a gate (authority).
+export const ApprovalAuthorityKind = defineClosedVocabulary({
+    Human: 'human',
+    Auto: 'auto',
+    Watch: 'watch',
+});

package/dist/src/orchestration/domain/activation-policy.js

@@ -0,0 +1,55 @@
+import { OrchestrationEventType } from '../contracts/events.js';
+import { childStartMetadata } from './child-policy.js';
+import { childStartDrafts } from './coordination-events.js';
+import { activation, startDraft, stateDraft } from './decision-events.js';
+export function startInstance(input) {
+    const stage = input.definition.stages[input.definition.entry];
+    const child = childStartMetadata(input);
+    const childEvents = child === undefined
+        ? []
+        : childStartDrafts({
+            workflowInstanceId: input.workflowInstanceId,
+            eventIdPrefix: input.causationId,
+            occurredAt: input.occurredAt,
+            correlationId: input.correlationId,
+            causationId: input.causationId,
+        }, child, input.definition.name);
+    return {
+        kind: 'append',
+        events: [
+            ...childEvents,
+            startDraft(input, OrchestrationEventType.InstanceStarted, {
+                workItemId: input.workItemId,
+                workflowName: input.definition.name,
+                orchestrationGroupId: input.orchestrationGroupId,
+                entry: input.definition.entry,
+                ...child,
+            }, childEvents.length + 1),
+            startDraft(input, OrchestrationEventType.StageEntered, { stage: input.definition.entry }, childEvents.length + 2),
+            startDraft(input, OrchestrationEventType.ActivityRequested, activation(input.workflowInstanceId, 1, stage.activity, stage.with, {
+                execution: stage.execution,
+                stage: input.definition.entry,
+            }), childEvents.length + 3),
+        ],
+    };
+}
+export function isPendingOutcome(state, input) {
+    return (state.pendingActivation !== undefined &&
+        state.pendingActivation.activationId === input.activationId &&
+        !state.acceptedOutcomes.includes(input.activationId));
+}
+export function acceptOutcomeDraft(state, input) {
+    return stateDraft(state, input, OrchestrationEventType.ActivityOutcomeAccepted, { activationId: input.activationId, outcome: input.outcome }, 1);
+}
+export function requestFollowOn(events, state, input, activities) {
+    const pending = state.pendingActivation;
+    const nextFollowOnIndex = (pending.followOnIndex ?? -1) + 1;
+    if (nextFollowOnIndex >= activities.length)
+        return false;
+    const next = activities[nextFollowOnIndex];
+    events.push(stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, pending.ordinal + 1, next.use, next.with, {
+        execution: undefined,
+        followOnIndex: nextFollowOnIndex,
+    }), events.length + 1));
+    return true;
+}

package/dist/src/orchestration/domain/approval-defaults.js

@@ -0,0 +1,17 @@
+import { ActivityOutcomeKind } from '../../activities/index.js';
+import { ApprovalAuthorityKind } from '../contracts/vocabulary.js';
+/**
+ * A `done` route with no explicit `await`/`watchGates` requires human
+ * approval before advancing by default, since a watchGate is itself an
+ * approval-equivalent and an explicit await is already what the author
+ * wants. A stage opts out with `requiresApproval: false`.
+ */
+export function defaultApprovalAwait(stage, outcomeKind, route) {
+    if (route.await !== undefined)
+        return route.await;
+    if (outcomeKind !== ActivityOutcomeKind.Done ||
+        route.watchGates !== undefined ||
+        stage.requiresApproval === false)
+        return undefined;
+    return { signal: 'approved', from: [ApprovalAuthorityKind.Human] };
+}

package/dist/src/orchestration/domain/child-policy.js

@@ -0,0 +1,63 @@
+import { workflowInstanceId, } from '../contracts/identifiers.js';
+import { WorkflowInstanceKind } from '../contracts/vocabulary.js';
+export function childStartMetadata(input) {
+    if (input.parentWorkflowInstanceId === undefined)
+        return undefined;
+    return {
+        parentWorkflowInstanceId: input.parentWorkflowInstanceId,
+        watchId: input.watchId,
+        triggerId: input.triggerId,
+        orchestrationGroupId: input.orchestrationGroupId,
+        causalCycleId: input.causalCycleId,
+        requestId: input.requestId,
+        childWorkflowInstanceId: input.workflowInstanceId,
+    };
+}
+export function childMetadata(child) {
+    if (child.parentWorkflowInstanceId === undefined ||
+        child.watchId === undefined ||
+        child.triggerId === undefined ||
+        child.causalCycleId === undefined ||
+        child.requestId === undefined)
+        throw new Error('Child workflow metadata is incomplete');
+    return {
+        parentWorkflowInstanceId: child.parentWorkflowInstanceId,
+        watchId: child.watchId,
+        triggerId: child.triggerId,
+        orchestrationGroupId: child.orchestrationGroupId,
+        causalCycleId: child.causalCycleId,
+        requestId: child.requestId,
+        childWorkflowInstanceId: child.workflowInstanceId,
+    };
+}
+export function validateChildProvenance(command) {
+    const values = [
+        command.parentWorkflowInstanceId,
+        command.watchId,
+        command.triggerId,
+        command.causalCycleId,
+        command.requestId,
+    ];
+    const provided = values.filter((value) => value !== undefined).length;
+    if (provided === 0)
+        return WorkflowInstanceKind.Primary;
+    if (provided !== values.length)
+        throw new Error('Complete child provenance must be provided');
+    if (command.requestId !== command.workflowInstanceId)
+        throw new Error('Child request id must equal its WorkflowInstance id');
+    return WorkflowInstanceKind.Child;
+}
+export function childRequestId(request) {
+    return workflowInstanceId(`${request.parentWorkflowInstanceId}:watch:${request.watchId}:trigger:${request.triggerId}`);
+}
+export function coordinationMetadata(parent, request) {
+    return {
+        parentWorkflowInstanceId: parent.workflowInstanceId,
+        watchId: request.watchId,
+        triggerId: request.triggerId,
+        orchestrationGroupId: parent.orchestrationGroupId,
+        causalCycleId: request.causalCycleId,
+        requestId: request.requestId,
+        childWorkflowInstanceId: request.requestId,
+    };
+}

package/dist/src/orchestration/domain/compiler.js

@@ -0,0 +1,162 @@
+import { activityName, ActivityOutcomeKind, } from '../../activities/index.js';
+import { workflowDefinitionConfigSchema, } from '../contracts/config.js';
+import { commandName, signalName, stageName, watchId, workflowName, } from '../contracts/identifiers.js';
+import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
+import { defaultApprovalAwait } from './approval-defaults.js';
+import { assertCyclesBounded, assertReachable } from './workflow-graph.js';
+export function compileWorkflow(name, input, activities, knownWorkflowNames = [name]) {
+    const compiledName = workflowName(name);
+    const config = workflowDefinitionConfigSchema.parse(input);
+    const rawStageNames = Object.keys(config.stages);
+    for (const candidate of rawStageNames) {
+        if (isReservedTerminal(candidate))
+            throw new Error(`Reserved stage name: ${candidate}`);
+    }
+    const stageNames = rawStageNames.map(stageName);
+    const entry = config.entry ?? stageNames[0];
+    if (!(entry in config.stages))
+        throw new Error(`Unknown workflow entry stage: ${entry}`);
+    const compiledEntry = stageName(entry);
+    const declaredWatchIds = new Set((config.watches ?? []).map((watch) => watch.id));
+    const stages = compileStages(compiledName, config.stages, activities, declaredWatchIds);
+    const commands = compileCommands(config, activities);
+    const watches = compileWatches(config, rawStageNames, knownWorkflowNames);
+    assertReachable(compiledEntry, stages);
+    assertCyclesBounded(stages);
+    return Object.freeze({
+        name: compiledName,
+        entry: compiledEntry,
+        commands: Object.freeze(commands),
+        watches: Object.freeze(watches),
+        stages: Object.freeze(stages),
+    });
+}
+function compileWatches(config, stageNames, knownWorkflowNames) {
+    const ids = new Set();
+    return (config.watches ?? []).map((watch) => {
+        if (ids.has(watch.id))
+            throw new Error(`Duplicate watch id: ${watch.id}`);
+        ids.add(watch.id);
+        const unknownStages = watch.while.stages.filter((stage) => !stageNames.includes(stage));
+        if (unknownStages.length > 0)
+            throw new Error(`Unknown watch stage: ${unknownStages.join(', ')}`);
+        if (!knownWorkflowNames.includes(watch.workflow))
+            throw new Error(`Unknown watch workflow: ${watch.workflow}`);
+        return Object.freeze({
+            ...watch,
+            id: watchId(watch.id),
+            workflow: workflowName(watch.workflow),
+            while: Object.freeze({
+                stages: Object.freeze(watch.while.stages.map(stageName)),
+                statuses: Object.freeze([...watch.while.statuses]),
+            }),
+            ...(watch.on === undefined
+                ? {}
+                : { on: Object.freeze({ events: Object.freeze([...watch.on.events]) }) }),
+            ...(watch.schedule === undefined ? {} : { schedule: Object.freeze({ ...watch.schedule }) }),
+        });
+    });
+}
+function compileStages(compiledWorkflowName, configured, activities, declaredWatchIds) {
+    const context = {
+        workflowName: compiledWorkflowName,
+        activities,
+        declaredWatchIds,
+    };
+    return Object.fromEntries(Object.entries(configured).map(([stageName, stage]) => [
+        stageName,
+        compileStage(context, stageName, stage, configured),
+    ]));
+}
+function compileStage(context, rawStageName, stage, allStages) {
+    const { workflowName: compiledWorkflowName, activities, declaredWatchIds } = context;
+    const definition = activities.describe(activityName(stage.activity));
+    const on = Object.fromEntries(Object.entries(stage.on).map(([outcomeKind, route]) => {
+        if (!definition.outcomeKinds.includes(outcomeKind))
+            throw new Error(`Workflow outcome route ${outcomeKind} is not declared by Activity ${definition.name}`);
+        if (!isReservedTerminal(route.then) && !(route.then in allStages))
+            throw new Error(`Unknown transition target: ${route.then}`);
+        if (route.await !== undefined && route.watchGates !== undefined)
+            throw new Error(`Route ${compiledWorkflowName}:${rawStageName}:${outcomeKind} cannot configure both await and watchGates`);
+        const followOns = route.activities?.map((activity) => ({
+            use: activityName(activity.use),
+            with: activities.validateInput(activityName(activity.use), activity.with),
+        }));
+        const target = compileTarget(route.then, outcomeKind);
+        const effectiveAwait = defaultApprovalAwait(stage, outcomeKind, route);
+        const compiled = Object.freeze({
+            target,
+            ...(route.repeat === undefined ? {} : { repeat: route.repeat }),
+            ...(route.retry === undefined ? {} : { retry: route.retry }),
+            ...(followOns === undefined ? {} : { activities: Object.freeze(followOns) }),
+            ...(effectiveAwait === undefined
+                ? {}
+                : {
+                    await: compileAwait(compiledWorkflowName, rawStageName, target, effectiveAwait, declaredWatchIds),
+                }),
+            ...(route.watchGates === undefined
+                ? {}
+                : {
+                    watchGates: compileWatchGates(compiledWorkflowName, rawStageName, outcomeKind, route.watchGates, declaredWatchIds, allStages),
+                }),
+            id: `${compiledWorkflowName}:${rawStageName}:${outcomeKind}`,
+        });
+        return [outcomeKind, compiled];
+    }));
+    return Object.freeze({
+        activity: definition.name,
+        with: activities.validateInput(definition.name, stage.with),
+        ...(stage.execution === undefined ? {} : { execution: stage.execution }),
+        on: Object.freeze(on),
+    });
+}
+function compileWatchGates(workflow, rawStageName, outcomeKind, entries, declaredWatchIds, allStages) {
+    if (entries.length !== 1)
+        throw new Error(`Route ${workflow}:${rawStageName}:${outcomeKind} configures ${entries.length} watchGates; exactly 1 is supported`);
+    return Object.freeze(entries.map((entry) => {
+        const normalized = typeof entry === 'string' ? { watch: entry } : entry;
+        if (!declaredWatchIds.has(normalized.watch))
+            throw new Error(`Unknown watch reference in workflow "${workflow}" stage "${rawStageName}": "${normalized.watch}"`);
+        const onRejectThen = normalized.onReject?.then ?? rawStageName;
+        if (!isReservedTerminal(onRejectThen) && !(onRejectThen in allStages))
+            throw new Error(`Unknown watchGates onReject target: ${onRejectThen}`);
+        return Object.freeze({
+            watch: watchId(normalized.watch),
+            onRejectTarget: compileTarget(onRejectThen, outcomeKind),
+        });
+    }));
+}
+function compileAwait(workflow, rawStageName, resume, config, declaredWatchIds) {
+    return Object.freeze({
+        signal: signalName(config.signal),
+        from: Object.freeze(config.from.map((entry) => compileAuthority(workflow, rawStageName, entry, declaredWatchIds))),
+        resume,
+    });
+}
+function compileAuthority(workflow, rawStageName, entry, declaredWatchIds) {
+    if (entry === ApprovalAuthorityKind.Human)
+        return { kind: ApprovalAuthorityKind.Human };
+    if (entry === ApprovalAuthorityKind.Auto)
+        return { kind: ApprovalAuthorityKind.Auto };
+    if (!declaredWatchIds.has(entry.id))
+        throw new Error(`Unknown watch reference in workflow "${workflow}" stage "${rawStageName}": "${entry.id}"`);
+    return { kind: ApprovalAuthorityKind.Watch, watch: watchId(entry.id) };
+}
+function compileCommands(config, activities) {
+    return Object.fromEntries(Object.entries(config.commands ?? {}).map(([command, configured]) => [
+        commandName(command),
+        Object.freeze({
+            activity: activityName(configured.activity),
+            with: activities.validateInput(activityName(configured.activity), configured.with),
+            allowedActors: Object.freeze([...configured.allowedActors]),
+        }),
+    ]));
+}
+const isReservedTerminal = (target) => target === ActivityOutcomeKind.Done || target === 'await-human';
+function compileTarget(target, outcomeKind) {
+    if (target === ActivityOutcomeKind.Done)
+        return { kind: TransitionTargetKind.Complete };
+    if (target === 'await-human')
+        return { kind: TransitionTargetKind.AwaitSignal, signal: signalName(outcomeKind) };
+    return { kind: TransitionTargetKind.Stage, stage: stageName(target) };
+}

package/dist/src/orchestration/domain/coordination-events.js

@@ -0,0 +1,25 @@
+import { createEventDraft, EventActorKind, EventSourceKind } from '../../kernel/index.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { workflowInstanceId, } from '../contracts/identifiers.js';
+import { workflowInstanceStream } from '../contracts/streams.js';
+const actor = { kind: EventActorKind.System, id: 'orchestration' };
+const source = { kind: EventSourceKind.Internal, id: 'orchestration' };
+export function coordinationDraft(context, eventType, payload, ordinal) {
+    return createEventDraft({
+        eventId: `${context.eventIdPrefix}:${eventType}:${ordinal}`,
+        eventType,
+        occurredAt: context.occurredAt,
+        correlationId: context.correlationId,
+        causationId: context.causationId,
+        actor,
+        source,
+        stream: workflowInstanceStream(workflowInstanceId(context.workflowInstanceId)),
+        payload,
+    });
+}
+export function childStartDrafts(context, metadata, workflowName) {
+    return [
+        coordinationDraft(context, OrchestrationEventType.ChildRequested, { ...metadata, workflowName }, 1),
+        coordinationDraft(context, OrchestrationEventType.ChildStarted, metadata, 2),
+    ];
+}

package/dist/src/orchestration/domain/decision-events.js

@@ -0,0 +1,47 @@
+import { activationId } from '../../activities/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind } from '../../kernel/index.js';
+import { workflowInstanceId, } from '../contracts/identifiers.js';
+import { workflowInstanceStream } from '../contracts/streams.js';
+const actor = { kind: EventActorKind.System, id: 'orchestration' };
+const source = { kind: EventSourceKind.Internal, id: 'orchestration' };
+export function nextOrdinal(state) {
+    return (state.pendingActivation?.ordinal ?? 0) + 1;
+}
+export function activation(id, ordinal, activity, input, options) {
+    return {
+        activationId: activationId(`${id}:activity:${ordinal}`),
+        ordinal,
+        activity,
+        ...(options.stage === undefined ? {} : { stage: options.stage }),
+        input,
+        execution: options.execution,
+        ...(options.followOnIndex === undefined ? {} : { followOnIndex: options.followOnIndex }),
+        ...(options.supplemental === true ? { supplemental: true } : {}),
+    };
+}
+export function startDraft(input, eventType, payload, ordinal) {
+    return createEventDraft({
+        eventId: `${input.causationId}:${eventType}:${ordinal}`,
+        eventType,
+        occurredAt: input.occurredAt,
+        correlationId: input.correlationId,
+        causationId: input.causationId,
+        actor,
+        source,
+        stream: workflowInstanceStream(workflowInstanceId(input.workflowInstanceId)),
+        payload,
+    });
+}
+export function stateDraft(state, input, eventType, payload, ordinal) {
+    return createEventDraft({
+        eventId: `${input.causationId}:${eventType}:${ordinal}`,
+        eventType,
+        occurredAt: input.occurredAt,
+        correlationId: state.orchestrationGroupId,
+        causationId: input.causationId,
+        actor,
+        source,
+        stream: workflowInstanceStream(workflowInstanceId(state.workflowInstanceId)),
+        payload,
+    });
+}

package/dist/src/orchestration/domain/interpreter.js

@@ -0,0 +1,49 @@
+import { ActivityOutcomeKind } from '../../activities/index.js';
+import { OrchestrationEventType, } from '../contracts/events.js';
+import { stageName } from '../contracts/identifiers.js';
+import { acceptOutcomeDraft, isPendingOutcome, requestFollowOn, } from './activation-policy.js';
+import { stateDraft } from './decision-events.js';
+import { mayRetry, requestRetry } from './retry-policy.js';
+import { acceptWaitingOutcome } from './signal-policy.js';
+import { finishSupplemental, requestNextSupplemental } from './supplemental-policy.js';
+import { finishRoute } from './transition.js';
+export { startInstance } from './activation-policy.js';
+export { acceptSignal, waitForSignal } from './signal-policy.js';
+export { requestSupplementalActivity } from './supplemental-policy.js';
+export { isOperatorRetryEligible, requestOperatorRetry } from './operator-retry-policy.js';
+export function acceptActivityOutcome(definition, state, input) {
+    if (!isPendingOutcome(state, input))
+        return { kind: 'ignored', reason: 'outcome is not for the pending activation' };
+    if (input.outcome.kind === ActivityOutcomeKind.Waiting)
+        return acceptWaitingOutcome(state, input);
+    const events = [acceptOutcomeDraft(state, input)];
+    const pending = state.pendingActivation;
+    if (pending.supplemental === true) {
+        finishSupplemental(events, definition, state, input);
+        return { kind: 'append', events };
+    }
+    const route = definition.stages[stageName(state.currentStage)]?.on[input.outcome.kind];
+    if (route === undefined) {
+        // The outcome still durably happened even though this stage never
+        // declared how to route it — recording it (not just blocking) is what
+        // keeps the activation resolved, so nothing can later mistake it for
+        // still being open and resolve it via an unrelated signal.
+        events.push(stateDraft(state, input, OrchestrationEventType.InstanceBlocked, { reason: `unconfigured outcome ${input.outcome.kind}` }, events.length + 1));
+        return { kind: 'append', events };
+    }
+    if (input.outcome.kind !== ActivityOutcomeKind.Done) {
+        if (mayRetry(route, state, input.outcome))
+            requestRetry(events, definition, state, input);
+        else
+            finishRoute(events, definition, state, input, route);
+        return { kind: 'append', events };
+    }
+    if (state.supplementalQueue.length > 0) {
+        requestNextSupplemental(events, state, input);
+        return { kind: 'append', events };
+    }
+    if (requestFollowOn(events, state, input, route.activities ?? []))
+        return { kind: 'append', events };
+    finishRoute(events, definition, state, input, route);
+    return { kind: 'append', events };
+}

package/dist/src/orchestration/domain/operator-retry-policy.js

@@ -0,0 +1,34 @@
+import { ActivityOutcomeKind } from '../../activities/index.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { stageName } from '../contracts/identifiers.js';
+import { ActivityActivationStatus, WorkflowStatus } from '../contracts/vocabulary.js';
+import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+export function isOperatorRetryEligible(view) {
+    const pending = view.pendingActivation;
+    return (view.status === WorkflowStatus.Blocked &&
+        view.blockReason === 'unconfigured outcome failed' &&
+        pending !== undefined &&
+        pending.status === ActivityActivationStatus.Completed &&
+        pending.supplemental !== true &&
+        pending.followOnIndex === undefined &&
+        view.lastOutcome?.kind === ActivityOutcomeKind.Failed &&
+        view.acceptedOutcomes.includes(pending.activationId));
+}
+export function requestOperatorRetry(definition, state, input) {
+    if (input.commandId.length === 0)
+        return { kind: 'ignored', reason: 'operator retry command id is required' };
+    if (!isOperatorRetryEligible(state))
+        return {
+            kind: 'ignored',
+            reason: 'workflow is not blocked for an unconfigured failed outcome',
+        };
+    const stage = definition.stages[stageName(state.currentStage)];
+    const events = [
+        stateDraft(state, input, OrchestrationEventType.OperatorRetryRequested, { activationId: state.pendingActivation.activationId, commandId: input.commandId }, 1),
+        stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, nextOrdinal(state), stage.activity, stage.with, {
+            execution: stage.execution,
+            stage: stageName(state.currentStage),
+        }), 2),
+    ];
+    return { kind: 'append', events };
+}

package/dist/src/orchestration/domain/retry-policy.js

@@ -0,0 +1,26 @@
+import { RetrySafety } from '../../activities/index.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { stageName } from '../contracts/identifiers.js';
+import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+export function mayRetry(route, state, outcome) {
+    if (route.retry === undefined || requiresReconciliation(outcome))
+        return false;
+    const retryKey = `${state.currentStage}:${outcome.kind}`;
+    return (state.retryCounts[retryKey] ?? 0) < route.retry.max;
+}
+export function requestRetry(events, definition, state, input) {
+    const retryKey = `${state.currentStage}:${input.outcome.kind}`;
+    const count = (state.retryCounts[retryKey] ?? 0) + 1;
+    const stage = definition.stages[stageName(state.currentStage)];
+    events.push(stateDraft(state, input, OrchestrationEventType.RetryCounted, { retryKey, count }, events.length + 1), stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, nextOrdinal(state), stage.activity, stage.with, {
+        execution: stage.execution,
+        stage: stageName(state.currentStage),
+    }), events.length + 2));
+}
+function requiresReconciliation(outcome) {
+    if (typeof outcome.data !== 'object' || outcome.data === null)
+        return false;
+    if (!('retrySafety' in outcome.data))
+        return false;
+    return outcome.data.retrySafety === RetrySafety.RequiresReconciliation;
+}

package/dist/src/orchestration/domain/signal-policy.js

@@ -0,0 +1,120 @@
+import { ActivityOutcomeKind } from '../../activities/index.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { stageName } from '../contracts/identifiers.js';
+import { ActivityActivationStatus, ApprovalAuthorityKind, WorkflowStatus, } from '../contracts/vocabulary.js';
+import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+import { resumeToTarget } from './transition.js';
+export function waitForSignal(state, expectation, input) {
+    if (state.status !== WorkflowStatus.Waiting && state.status !== WorkflowStatus.Blocked)
+        return { kind: 'ignored', reason: 'WorkflowInstance is not waiting or blocked' };
+    if (expectation.signalKind.trim().length === 0)
+        return { kind: 'ignored', reason: 'signal kind must not be empty' };
+    return {
+        kind: 'append',
+        events: [stateDraft(state, input, OrchestrationEventType.SignalWaitStarted, expectation, 1)],
+    };
+}
+export function acceptSignal(definition, state, input) {
+    const rejection = signalRejectionReason(state, input);
+    if (rejection !== null)
+        return { kind: 'ignored', reason: rejection };
+    const signal = input.signal;
+    const expected = state.waitingFor;
+    const authority = signal.authority ?? { kind: ApprovalAuthorityKind.Human };
+    const events = [
+        stateDraft(state, input, OrchestrationEventType.SignalAccepted, { ...signal, authority }, 1),
+    ];
+    if (signal.outcome === ActivityOutcomeKind.Rejected) {
+        if (expected.onRejectResume !== undefined) {
+            resumeToTarget(events, definition, state, input, expected.onRejectResume);
+        }
+        else {
+            requestCurrentStage(events, definition, state, input);
+        }
+    }
+    else if (expected.resume !== undefined) {
+        resumeToTarget(events, definition, state, input, expected.resume);
+    }
+    else {
+        requestCurrentStage(events, definition, state, input);
+    }
+    return { kind: 'append', events };
+}
+function requestCurrentStage(events, definition, state, input) {
+    const stage = definition.stages[stageName(state.currentStage)];
+    events.push(stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, nextOrdinal(state), stage.activity, stage.with, {
+        execution: stage.execution,
+        stage: stageName(state.currentStage),
+    }), events.length + 1));
+}
+function signalRejectionReason(state, input) {
+    const signal = input.signal;
+    if (state.acceptedSignalIds.includes(signal.providerEventId))
+        return 'provider signal was already accepted';
+    const expected = state.waitingFor;
+    if (state.status !== WorkflowStatus.Waiting || expected === undefined)
+        return 'WorkflowInstance is not waiting for a signal';
+    if (!matchesExpectation(signal, expected))
+        return 'signal does not match the current expectation';
+    if (!hasDecisionEvidence(signal))
+        return 'signal lacks authorized actor decision evidence';
+    if (signal.providerEventId.trim().length === 0)
+        return 'signal lacks provider event identity';
+    if (!signalAuthorityAccepted(signal, expected, input.consent ?? false))
+        return 'signal authority is not accepted by this wait';
+    if (!watchGateOutcomeAccepted(signal, expected))
+        return 'watch-gate signal outcome is neither done nor rejected';
+    return null;
+}
+function signalAuthorityAccepted(signal, expected, consent) {
+    if (expected.from === undefined)
+        return true;
+    const authority = signal.authority ?? { kind: ApprovalAuthorityKind.Human };
+    return authorityAccepted(authority, expected.from, consent);
+}
+function watchGateOutcomeAccepted(signal, expected) {
+    return (expected.onRejectResume === undefined ||
+        signal.outcome === undefined ||
+        signal.outcome === ActivityOutcomeKind.Done ||
+        signal.outcome === ActivityOutcomeKind.Rejected);
+}
+function authorityAccepted(authority, declared, consent) {
+    switch (authority.kind) {
+        case ApprovalAuthorityKind.Human:
+            return declared.some((entry) => entry.kind === ApprovalAuthorityKind.Human);
+        case ApprovalAuthorityKind.Auto:
+            return consent && declared.some((entry) => entry.kind === ApprovalAuthorityKind.Auto);
+        case ApprovalAuthorityKind.Watch:
+            return declared.some((entry) => entry.kind === ApprovalAuthorityKind.Watch && entry.watch === authority.watch);
+        default:
+            return false;
+    }
+}
+export function acceptWaitingOutcome(state, input) {
+    const waiting = waitingOutcome(input.outcome);
+    if (waiting === null)
+        return { kind: 'ignored', reason: 'waiting outcome lacks expectation' };
+    if (state.pendingActivation?.status === ActivityActivationStatus.Waiting &&
+        state.waitingFor?.intentEventId === waiting.data.intentEventId &&
+        state.waitingFor.signalKind === waiting.data.signalKind)
+        return { kind: 'ignored', reason: 'waiting outcome was already recorded' };
+    const events = [
+        stateDraft(state, input, OrchestrationEventType.ActivityWaiting, { activationId: input.activationId, outcome: waiting }, 1),
+    ];
+    return { kind: 'append', events };
+}
+function matchesExpectation(signal, expected) {
+    return (signal.kind === expected?.signalKind &&
+        signal.resourceId === expected.resourceId &&
+        signal.revision === expected.revision);
+}
+function hasDecisionEvidence(signal) {
+    return (signal.actorId.trim().length > 0 &&
+        signal.actorDecision.authorized &&
+        signal.actorDecision.evidenceId.trim().length > 0);
+}
+function waitingOutcome(outcome) {
+    return outcome.kind === ActivityOutcomeKind.Waiting
+        ? outcome
+        : null;
+}