@codemation/core 0.0.1

package/src/execution/CredentialResolverFactory.ts

@@ -0,0 +1,39 @@
+import type { CredentialSessionService, NodeExecutionContext, NodeId, WorkflowId } from "../types";
+
+export class CredentialResolverFactory {
+  constructor(private readonly credentialSessions: CredentialSessionService) {}
+
+  create(
+    workflowId: WorkflowId,
+    nodeId: NodeId,
+    config?: NodeExecutionContext["config"],
+  ): NodeExecutionContext["getCredential"] {
+    const acceptedTypesBySlot = new Map<string, ReadonlyArray<string>>();
+    for (const requirement of config?.getCredentialRequirements?.() ?? []) {
+      acceptedTypesBySlot.set(requirement.slotKey, requirement.acceptedTypes);
+    }
+
+    return async <TSession = unknown>(slotKey: string): Promise<TSession> => {
+      try {
+        return await this.credentialSessions.getSession<TSession>({
+          workflowId,
+          nodeId,
+          slotKey,
+        });
+      } catch (error) {
+        const acceptedTypes = acceptedTypesBySlot.get(slotKey) ?? [];
+        const message = error instanceof Error ? error.message : String(error);
+        const alreadyListsAcceptedTypes =
+          message.includes("Accepted types:") ||
+          message.includes("Accepted credential types:") ||
+          message.includes("binding points at an unknown type");
+        const acceptedTypesSuffix =
+          acceptedTypes.length > 0 && !alreadyListsAcceptedTypes ? ` Accepted types: ${acceptedTypes.join(", ")}.` : "";
+        throw new Error(
+          `Failed to resolve credential for workflow ${workflowId} node ${nodeId} slot "${slotKey}". ${message}${acceptedTypesSuffix}`,
+          { cause: error },
+        );
+      }
+    };
+  }
+}

package/src/execution/DefaultAsyncSleeper.ts

@@ -0,0 +1,9 @@
+import type { AsyncSleeper } from "./asyncSleeper.types";
+
+export class DefaultAsyncSleeper implements AsyncSleeper {
+  sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+}

package/src/execution/DefaultExecutionContextFactory.ts

@@ -0,0 +1,48 @@
+import type {
+  BinaryStorage,
+  ExecutionContext,
+  ExecutionContextFactory,
+  NodeExecutionStatePublisher,
+  ParentExecutionRef,
+  RunDataSnapshot,
+  RunId,
+  WorkflowId,
+} from "../types";
+
+import {
+  DefaultExecutionBinaryService,
+  UnavailableBinaryStorage,
+} from "../binaries/DefaultExecutionBinaryServiceFactory";
+
+export class DefaultExecutionContextFactory implements ExecutionContextFactory {
+  constructor(
+    private readonly binaryStorage: BinaryStorage = new UnavailableBinaryStorage(),
+    private readonly currentDate: () => Date = () => new Date(),
+  ) {}
+
+  create(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    parent?: ParentExecutionRef;
+    subworkflowDepth: number;
+    engineMaxNodeActivations: number;
+    engineMaxSubworkflowDepth: number;
+    data: RunDataSnapshot;
+    nodeState?: NodeExecutionStatePublisher;
+    getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+  }): ExecutionContext {
+    return {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      parent: args.parent,
+      subworkflowDepth: args.subworkflowDepth,
+      engineMaxNodeActivations: args.engineMaxNodeActivations,
+      engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
+      now: this.currentDate,
+      data: args.data,
+      nodeState: args.nodeState,
+      binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
+      getCredential: args.getCredential,
+    };
+  }
+}

package/src/execution/InProcessRetryRunner.ts

@@ -0,0 +1,115 @@
+import type {
+  ExponentialRetryPolicySpec,
+  FixedRetryPolicySpec,
+  RetryPolicySpec,
+} from "../contracts/retryPolicySpec.types";
+import type { AsyncSleeper } from "./asyncSleeper.types";
+
+export type { AsyncSleeper } from "./asyncSleeper.types";
+
+type NormalizedPolicy =
+  | { readonly kind: "none"; readonly maxAttempts: 1 }
+  | { readonly kind: "fixed"; readonly maxAttempts: number; readonly delayMs: number }
+  | {
+      readonly kind: "exponential";
+      readonly maxAttempts: number;
+      readonly initialDelayMs: number;
+      readonly multiplier: number;
+      readonly maxDelayMs?: number;
+      readonly jitter?: boolean;
+    };
+
+export class InProcessRetryRunner {
+  constructor(private readonly sleeper: AsyncSleeper) {}
+
+  async run<T>(policy: RetryPolicySpec | undefined, work: () => Promise<T>): Promise<T> {
+    const spec = InProcessRetryRunner.normalizePolicy(policy);
+    let lastError: unknown;
+    for (let attempt = 1; attempt <= spec.maxAttempts; attempt++) {
+      try {
+        return await work();
+      } catch (error) {
+        lastError = error;
+        if (attempt >= spec.maxAttempts) {
+          break;
+        }
+        const delayMs = InProcessRetryRunner.delayAfterFailureMs(spec, attempt);
+        await this.sleeper.sleep(delayMs);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+
+  private static delayAfterFailureMs(spec: NormalizedPolicy, failedAttempt: number): number {
+    if (spec.kind === "none") {
+      return 0;
+    }
+    if (spec.kind === "fixed") {
+      return spec.delayMs;
+    }
+    const exponent = failedAttempt - 1;
+    let ms = spec.initialDelayMs * Math.pow(spec.multiplier, exponent);
+    if (spec.jitter === true) {
+      ms *= 1 + Math.random() * 0.2;
+    }
+    if (spec.maxDelayMs !== undefined && ms > spec.maxDelayMs) {
+      ms = spec.maxDelayMs;
+    }
+    return Math.max(0, Math.floor(ms));
+  }
+
+  private static normalizePolicy(policy: RetryPolicySpec | undefined): NormalizedPolicy {
+    if (policy === undefined) {
+      return { kind: "none", maxAttempts: 1 };
+    }
+    if (typeof policy !== "object" || policy === null) {
+      return { kind: "none", maxAttempts: 1 };
+    }
+    const kind = (policy as { kind?: unknown }).kind;
+    if (kind === "none") {
+      return { kind: "none", maxAttempts: 1 };
+    }
+    if (kind === "fixed") {
+      const p = policy as FixedRetryPolicySpec;
+      const maxAttempts = InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts");
+      const delayMs = InProcessRetryRunner.assertNonNegativeFinite(p.delayMs, "fixed.delayMs");
+      return { kind: "fixed", maxAttempts, delayMs };
+    }
+    if (kind === "exponential") {
+      const p = policy as ExponentialRetryPolicySpec;
+      return {
+        kind: "exponential",
+        maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts"),
+        initialDelayMs: InProcessRetryRunner.assertNonNegativeFinite(p.initialDelayMs, "exponential.initialDelayMs"),
+        multiplier: InProcessRetryRunner.assertMultiplier(p.multiplier),
+        maxDelayMs:
+          p.maxDelayMs === undefined
+            ? undefined
+            : InProcessRetryRunner.assertNonNegativeFinite(p.maxDelayMs, "exponential.maxDelayMs"),
+        jitter: p.jitter === true,
+      };
+    }
+    return { kind: "none", maxAttempts: 1 };
+  }
+
+  private static assertPositiveInt(value: unknown, label: string): number {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || !Number.isInteger(value)) {
+      throw new Error(`Retry policy ${label} must be a positive integer`);
+    }
+    return value;
+  }
+
+  private static assertNonNegativeFinite(value: unknown, label: string): number {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      throw new Error(`Retry policy ${label} must be a non-negative finite number`);
+    }
+    return value;
+  }
+
+  private static assertMultiplier(value: unknown): number {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+      throw new Error(`Retry policy exponential.multiplier must be >= 1`);
+    }
+    return value;
+  }
+}

package/src/execution/InProcessRetryRunnerFactory.ts

@@ -0,0 +1,8 @@
+import { DefaultAsyncSleeper } from "./DefaultAsyncSleeper";
+import { InProcessRetryRunner } from "./InProcessRetryRunner";
+
+export class InProcessRetryRunnerFactory {
+  create(defaultAsyncSleeper: DefaultAsyncSleeper): InProcessRetryRunner {
+    return new InProcessRetryRunner(defaultAsyncSleeper);
+  }
+}

package/src/execution/NodeActivationRequestComposer.ts

@@ -0,0 +1,113 @@
+import type {
+  ActivationIdFactory,
+  ExecutionContextFactory,
+  Items,
+  NodeActivationRequest,
+  NodeExecutionContext,
+  NodeId,
+  ParentExecutionRef,
+  RunDataFactory,
+  RunExecutionOptions,
+  RunId,
+  WorkflowId,
+} from "../types";
+
+import type { PlannedActivation } from "../planning/RunQueuePlanner";
+
+import { CredentialResolverFactory } from "./CredentialResolverFactory";
+
+type NodeExecutionDefinition = Readonly<{ id: NodeId; config: NodeExecutionContext["config"] }>;
+
+type NodeActivationContextArgs = {
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  base: ReturnType<ExecutionContextFactory["create"]>;
+  data: ReturnType<RunDataFactory["create"]>;
+};
+
+export type SingleDefinitionActivationRequest = NodeActivationContextArgs & {
+  definition: NodeExecutionDefinition;
+  batchId: string;
+  input: Items;
+};
+
+export type PlannedNodeActivationRequest = NodeActivationContextArgs & {
+  next: PlannedActivation;
+  nodeDefinition: NodeExecutionDefinition;
+};
+
+/**
+ * Builds {@link NodeActivationRequest} values shared by workflow starters and continuation.
+ */
+export class NodeActivationRequestComposer {
+  constructor(
+    private readonly activationIdFactory: ActivationIdFactory,
+    private readonly credentialResolverFactory: CredentialResolverFactory,
+  ) {}
+
+  createSingleFromDefinition(args: SingleDefinitionActivationRequest): NodeActivationRequest {
+    const activationId = this.activationIdFactory.makeActivationId();
+    const ctx = this.createNodeExecutionContext(args, args.definition, activationId);
+    return {
+      kind: "single",
+      runId: args.runId,
+      activationId,
+      workflowId: args.workflowId,
+      nodeId: args.definition.id,
+      parent: args.parent,
+      executionOptions: args.executionOptions,
+      batchId: args.batchId,
+      input: args.input,
+      ctx,
+    };
+  }
+
+  createFromPlannedActivation(args: PlannedNodeActivationRequest): NodeActivationRequest {
+    const activationId = this.activationIdFactory.makeActivationId();
+    const ctx = this.createNodeExecutionContext(args, args.nodeDefinition, activationId);
+    if (args.next.kind === "multi") {
+      return {
+        kind: "multi",
+        runId: args.runId,
+        activationId,
+        workflowId: args.workflowId,
+        nodeId: args.nodeDefinition.id,
+        parent: args.parent,
+        executionOptions: args.executionOptions,
+        batchId: args.next.batchId,
+        inputsByPort: args.next.inputsByPort,
+        ctx,
+      };
+    }
+    return {
+      kind: "single",
+      runId: args.runId,
+      activationId,
+      workflowId: args.workflowId,
+      nodeId: args.nodeDefinition.id,
+      parent: args.parent,
+      executionOptions: args.executionOptions,
+      batchId: args.next.batchId,
+      input: args.next.input,
+      ctx,
+    };
+  }
+
+  private createNodeExecutionContext(
+    args: NodeActivationContextArgs,
+    definition: NodeExecutionDefinition,
+    activationId: string,
+  ): NodeExecutionContext {
+    return {
+      ...args.base,
+      data: args.data,
+      nodeId: definition.id,
+      activationId,
+      config: definition.config,
+      binary: args.base.binary.forNode({ nodeId: definition.id, activationId }),
+      getCredential: this.credentialResolverFactory.create(args.workflowId, definition.id, definition.config),
+    };
+  }
+}

package/src/execution/NodeExecutionSnapshotFactory.ts

@@ -0,0 +1,152 @@
+import type {
+  NodeActivationId,
+  NodeExecutionSnapshot,
+  NodeId,
+  NodeInputsByPort,
+  NodeOutputs,
+  ParentExecutionRef,
+  RunId,
+  WorkflowId,
+} from "../types";
+
+export class NodeExecutionSnapshotFactory {
+  static queued(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+    parent?: ParentExecutionRef;
+    queuedAt: string;
+    inputsByPort: NodeInputsByPort;
+  }): NodeExecutionSnapshot {
+    return {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      nodeId: args.nodeId,
+      activationId: args.activationId,
+      parent: args.parent,
+      status: "queued",
+      queuedAt: args.queuedAt,
+      updatedAt: args.queuedAt,
+      inputsByPort: args.inputsByPort,
+    };
+  }
+
+  static running(args: {
+    previous?: NodeExecutionSnapshot;
+    runId: RunId;
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+    parent?: ParentExecutionRef;
+    startedAt: string;
+    inputsByPort: NodeInputsByPort;
+  }): NodeExecutionSnapshot {
+    return {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      nodeId: args.nodeId,
+      activationId: args.activationId,
+      parent: args.parent,
+      status: "running",
+      queuedAt: args.previous?.queuedAt,
+      startedAt: args.startedAt,
+      updatedAt: args.startedAt,
+      inputsByPort: args.inputsByPort,
+      outputs: args.previous?.outputs,
+      error: undefined,
+    };
+  }
+
+  static completed(args: {
+    previous?: NodeExecutionSnapshot;
+    runId: RunId;
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+    parent?: ParentExecutionRef;
+    finishedAt: string;
+    inputsByPort: NodeInputsByPort;
+    outputs: NodeOutputs;
+    fromPinnedOutput?: boolean;
+  }): NodeExecutionSnapshot {
+    const fromPinnedOutput = args.fromPinnedOutput ?? false;
+    const startedAt = fromPinnedOutput ? (args.previous?.startedAt ?? args.finishedAt) : args.previous?.startedAt;
+    return {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      nodeId: args.nodeId,
+      activationId: args.activationId,
+      parent: args.parent,
+      status: "completed",
+      queuedAt: args.previous?.queuedAt,
+      startedAt,
+      finishedAt: args.finishedAt,
+      updatedAt: args.finishedAt,
+      inputsByPort: args.inputsByPort,
+      outputs: args.outputs,
+      usedPinnedOutput: fromPinnedOutput,
+      error: undefined,
+    };
+  }
+
+  static skipped(args: {
+    previous?: NodeExecutionSnapshot;
+    runId: RunId;
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+    parent?: ParentExecutionRef;
+    finishedAt: string;
+    inputsByPort: NodeInputsByPort;
+    outputs: NodeOutputs;
+  }): NodeExecutionSnapshot {
+    return {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      nodeId: args.nodeId,
+      activationId: args.activationId,
+      parent: args.parent,
+      status: "skipped",
+      queuedAt: args.previous?.queuedAt,
+      startedAt: args.previous?.startedAt,
+      finishedAt: args.finishedAt,
+      updatedAt: args.finishedAt,
+      inputsByPort: args.inputsByPort,
+      outputs: args.outputs,
+      error: undefined,
+    };
+  }
+
+  static failed(args: {
+    previous?: NodeExecutionSnapshot;
+    runId: RunId;
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+    parent?: ParentExecutionRef;
+    finishedAt: string;
+    inputsByPort: NodeInputsByPort;
+    error: Error;
+  }): NodeExecutionSnapshot {
+    return {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      nodeId: args.nodeId,
+      activationId: args.activationId,
+      parent: args.parent,
+      status: "failed",
+      queuedAt: args.previous?.queuedAt,
+      startedAt: args.previous?.startedAt,
+      finishedAt: args.finishedAt,
+      updatedAt: args.finishedAt,
+      inputsByPort: args.inputsByPort,
+      outputs: undefined,
+      error: {
+        message: args.error.message,
+        name: args.error.name,
+        stack: args.error.stack,
+      },
+    };
+  }
+}

package/src/execution/NodeExecutor.ts

@@ -0,0 +1,43 @@
+import type { MultiInputNode, Node, NodeActivationRequest, NodeOutputs, WorkflowNodeInstanceFactory } from "../types";
+
+import { InProcessRetryRunner } from "./InProcessRetryRunner";
+
+export class NodeExecutor {
+  constructor(
+    private readonly nodeInstanceFactory: WorkflowNodeInstanceFactory,
+    private readonly retryRunner: InProcessRetryRunner,
+  ) {}
+
+  async execute(request: NodeActivationRequest): Promise<NodeOutputs> {
+    const policy = request.ctx.config.retryPolicy;
+    return await this.retryRunner.run(policy, async () => {
+      const nodeInstance = this.nodeInstanceFactory.createByType(request.ctx.config.type);
+      if (request.kind === "multi") {
+        return await this.executeMultiInputNode(request, nodeInstance);
+      }
+      return await this.executeSingleInputNode(request, nodeInstance);
+    });
+  }
+
+  private async executeMultiInputNode(
+    request: Extract<NodeActivationRequest, { kind: "multi" }>,
+    node: unknown,
+  ): Promise<NodeOutputs> {
+    const multiInputNode = node as MultiInputNode;
+    if (typeof (multiInputNode as { executeMulti?: unknown }).executeMulti !== "function") {
+      throw new Error(`Node ${request.nodeId} does not support executeMulti but received multi-input activation`);
+    }
+    return await multiInputNode.executeMulti(request.inputsByPort, request.ctx as any);
+  }
+
+  private async executeSingleInputNode(
+    request: Extract<NodeActivationRequest, { kind: "single" }>,
+    node: unknown,
+  ): Promise<NodeOutputs> {
+    const singleInputNode = node as Node;
+    if (typeof (singleInputNode as { execute?: unknown }).execute !== "function") {
+      throw new Error(`Node ${request.nodeId} does not support execute but received single-input activation`);
+    }
+    return await singleInputNode.execute(request.input, request.ctx as any);
+  }
+}

package/src/execution/NodeExecutorFactory.ts

@@ -0,0 +1,10 @@
+import type { WorkflowNodeInstanceFactory } from "../types";
+
+import { InProcessRetryRunner } from "./InProcessRetryRunner";
+import { NodeExecutor } from "./NodeExecutor";
+
+export class NodeExecutorFactory {
+  create(workflowNodeInstanceFactory: WorkflowNodeInstanceFactory, retryRunner: InProcessRetryRunner): NodeExecutor {
+    return new NodeExecutor(workflowNodeInstanceFactory, retryRunner);
+  }
+}

package/src/execution/NodeInputsByPortFactory.ts

@@ -0,0 +1,14 @@
+import type { NodeActivationRequest, NodeInputsByPort } from "../types";
+
+export class NodeInputsByPortFactory {
+  static empty(): NodeInputsByPort {
+    return {};
+  }
+
+  static fromRequest(request: NodeActivationRequest): NodeInputsByPort {
+    if (request.kind === "multi") {
+      return request.inputsByPort;
+    }
+    return { in: request.input };
+  }
+}

package/src/execution/NodeInstanceFactory.ts

@@ -0,0 +1,32 @@
+import type { TypeToken } from "../di";
+import type { NodeId, NodeResolver, WorkflowDefinition, WorkflowNodeInstanceFactory } from "../types";
+
+import { MissingRuntimeNode, MissingRuntimeTrigger } from "../workflowSnapshots";
+import { MissingRuntimeNodeToken } from "../workflowSnapshots/MissingRuntimeNodeToken";
+import { MissingRuntimeTriggerToken } from "../workflowSnapshots/MissingRuntimeTriggerToken";
+
+export class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
+  constructor(private readonly nodeResolver: NodeResolver) {}
+
+  createNodes(workflow: WorkflowDefinition): Map<NodeId, unknown> {
+    const nodeInstances = new Map<NodeId, unknown>();
+    for (const definition of workflow.nodes) {
+      nodeInstances.set(definition.id, this.createNode(definition));
+    }
+    return nodeInstances;
+  }
+
+  createNode(definition: WorkflowDefinition["nodes"][number]): unknown {
+    return this.createByType(definition.type);
+  }
+
+  createByType(type: TypeToken<unknown>): unknown {
+    if (type === MissingRuntimeNodeToken) {
+      return new MissingRuntimeNode();
+    }
+    if (type === MissingRuntimeTriggerToken) {
+      return new MissingRuntimeTrigger();
+    }
+    return this.nodeResolver.resolve(type);
+  }
+}

package/src/execution/NodeInstanceFactoryFactory.ts

@@ -0,0 +1,9 @@
+import type { NodeResolver } from "../types";
+
+import { NodeInstanceFactory } from "./NodeInstanceFactory";
+
+export class NodeInstanceFactoryFactory {
+  create(nodeResolver: NodeResolver): NodeInstanceFactory {
+    return new NodeInstanceFactory(nodeResolver);
+  }
+}