@lotiai/composer 0.2.0 → 0.2.1

package/dist/internal/async/execute/workflow-execution.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Workflow Execution Integration for Temporal
+ *
+ * This module provides the integration layer between the synchronous workflow API
+ * (runWorkflow) and the Temporal async execution runtime. It bridges the gap by:
+ * - Converting sync workflow definitions to Temporal inputs
+ * - Integrating with the observability system (metrics/tracing)
+ * - Managing workflow lifecycle (start/success/failure)
+ * - Supporting early returns via checkpoints
+ *
+ * This is the glue layer that makes Temporal execution transparent to users of
+ * the synchronous runWorkflow() API.
+ *
+ * @module workflow-execution
+ */
+import type { VersioningOverride } from "@temporalio/common";
+import { type Workflow, type WorkflowResult } from "../../dag-sync-workflow";
+import type { UUIDV7 } from "../../types";
+/**
+ * Options for Temporal workflow execution.
+ */
+export interface TemporalExecutionOptions {
+    workflowId: UUIDV7;
+    /**
+     * Temporal server connection configuration.
+     */
+    clientConfig: {
+        address: string;
+        namespace: string;
+    };
+    /**
+     * Versioning override for Worker Versioning.
+     */
+    versioningOverride?: VersioningOverride;
+    /**
+     * Optional checkpoint name to await.
+     * If specified, returns partial bag state when checkpoint is reached
+     * instead of waiting for full workflow completion.
+     *
+     * The checkpoint must exist in the workflow definition.
+     * Timeout is determined by the checkpoint's configured timeout
+     * or DEFAULT_CHECKPOINT_TIMEOUT_MS (30s).
+     */
+    awaitCheckpoint?: string;
+    /**
+     * Start the workflow and return as soon as Temporal acknowledges execution.
+     *
+     * Unlike awaitCheckpoint, this does not wait for any workflow progress beyond
+     * successful handoff to Temporal.
+     */
+    startOnly?: boolean;
+}
+/**
+ * Executes a workflow using Temporal runtime.
+ *
+ * This function:
+ * 1. Creates a WorkflowInput from the initial data
+ * 2. Calls the Temporal client to execute the workflow
+ * 3. Returns WorkflowResult with bag and optional error (never throws)
+ *
+ * ## Checkpoints:
+ *
+ * If `options.awaitCheckpoint` is specified, the function returns early when
+ * that checkpoint is reached, providing partial results while the workflow
+ * continues executing in the background. Useful for fast HTTP responses.
+ *
+ * ## Observability:
+ *
+ * Temporal workflows rely on Temporal's built-in observability (metrics, traces, logs).
+ * Activity-level observability (spans, metrics) should be added in the activity workers.
+ * For now, use Temporal UI and Prometheus metrics for workflow monitoring.
+ * Cross-span correlation is handled automatically via OpenTelemetry trace context propagation.
+ *
+ * @param wf - The workflow definition to execute
+ * @param initialData - Initial data for the workflow
+ * @param options - Temporal execution options
+ * @returns WorkflowResult with bag and optional error
+ *
+ * @internal
+ */
+export declare function executeWorkflowTemporal<Bag extends Record<string, any>>(wf: Workflow<Bag, any, any>, initialData: Partial<Bag>, options: TemporalExecutionOptions): Promise<WorkflowResult<Bag>>;
+/**
+ * Starts a workflow on Temporal without waiting for completion (fire-and-forget).
+ *
+ * Returns the workflowId immediately. The workflow executes in the background
+ * on Temporal workers. Use this for 202 Accepted HTTP responses.
+ *
+ * @param wf - The workflow definition to execute
+ * @param initialData - Initial data for the workflow
+ * @param options - Temporal execution options
+ * @returns The workflowId of the started workflow
+ *
+ * @internal
+ */
+export declare function startWorkflowTemporal<Bag extends Record<string, any>>(wf: Workflow<Bag, any, any>, initialData: Partial<Bag>, options: Pick<TemporalExecutionOptions, "workflowId" | "clientConfig" | "versioningOverride">): Promise<{
+    workflowId: string;
+}>;
+//# sourceMappingURL=workflow-execution.d.ts.map

package/dist/internal/async/execute/workflow-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-execution.d.ts","sourceRoot":"","sources":["../../../../src/internal/async/execute/workflow-execution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAK1C;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,EAAE;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IAEF;;OAEG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IAExC;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3E,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAC3B,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,EACzB,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CA+H9B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzE,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAC3B,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,EACzB,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,YAAY,GAAG,cAAc,GAAG,oBAAoB,CAAC,GAC5F,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAwBjC"}

package/dist/internal/async/execute/workflow-execution.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Workflow Execution Integration for Temporal
+ *
+ * This module provides the integration layer between the synchronous workflow API
+ * (runWorkflow) and the Temporal async execution runtime. It bridges the gap by:
+ * - Converting sync workflow definitions to Temporal inputs
+ * - Integrating with the observability system (metrics/tracing)
+ * - Managing workflow lifecycle (start/success/failure)
+ * - Supporting early returns via checkpoints
+ *
+ * This is the glue layer that makes Temporal execution transparent to users of
+ * the synchronous runWorkflow() API.
+ *
+ * @module workflow-execution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorkflowTemporal = executeWorkflowTemporal;
+exports.startWorkflowTemporal = startWorkflowTemporal;
+const client_1 = require("@temporalio/client");
+const dag_sync_workflow_1 = require("../../dag-sync-workflow");
+const workflow_factory_1 = require("../build/workflow-factory");
+const temporal_client_1 = require("./temporal-client");
+/**
+ * Executes a workflow using Temporal runtime.
+ *
+ * This function:
+ * 1. Creates a WorkflowInput from the initial data
+ * 2. Calls the Temporal client to execute the workflow
+ * 3. Returns WorkflowResult with bag and optional error (never throws)
+ *
+ * ## Checkpoints:
+ *
+ * If `options.awaitCheckpoint` is specified, the function returns early when
+ * that checkpoint is reached, providing partial results while the workflow
+ * continues executing in the background. Useful for fast HTTP responses.
+ *
+ * ## Observability:
+ *
+ * Temporal workflows rely on Temporal's built-in observability (metrics, traces, logs).
+ * Activity-level observability (spans, metrics) should be added in the activity workers.
+ * For now, use Temporal UI and Prometheus metrics for workflow monitoring.
+ * Cross-span correlation is handled automatically via OpenTelemetry trace context propagation.
+ *
+ * @param wf - The workflow definition to execute
+ * @param initialData - Initial data for the workflow
+ * @param options - Temporal execution options
+ * @returns WorkflowResult with bag and optional error
+ *
+ * @internal
+ */
+async function executeWorkflowTemporal(wf, initialData, options) {
+    // Merge configured values with initial data (like sync path does)
+    // This ensures workflows that use .configure() work the same in both modes
+    const mergedInitialData = {
+        ...initialData,
+        ...(wf.configuredValues ?? {}),
+    };
+    try {
+        if (options.startOnly && options.awaitCheckpoint) {
+            throw new Error("Cannot use startOnly and awaitCheckpoint together");
+        }
+        // Validate checkpoint name and resolve timeout if awaitCheckpoint is specified
+        let checkpointTimeoutMs;
+        if (options.awaitCheckpoint) {
+            const checkpoint = wf.checkpoints?.find((c) => c.name === options.awaitCheckpoint);
+            if (!checkpoint) {
+                const validNames = wf.checkpoints?.map((c) => c.name).join(", ") ?? "none";
+                throw new Error(`Unknown checkpoint "${options.awaitCheckpoint}" for workflow "${wf.name}". ` +
+                    `Valid checkpoints: [${validNames}]`);
+            }
+            checkpointTimeoutMs = checkpoint.timeout ?? dag_sync_workflow_1.DEFAULT_CHECKPOINT_TIMEOUT_MS;
+        }
+        const clientConfig = options.clientConfig;
+        const workflowInput = {
+            initialData: mergedInitialData,
+        };
+        if (options.startOnly) {
+            await (0, temporal_client_1.executeWorkflow)({
+                workflowName: wf.name,
+                workflowId: options.workflowId,
+                input: workflowInput,
+                taskQueue: "workflow-tasks",
+                clientConfig,
+            });
+            return { bag: mergedInitialData, error: undefined };
+        }
+        if (options.awaitCheckpoint) {
+            // Start the workflow (don't wait for completion)
+            await (0, temporal_client_1.executeWorkflow)({
+                workflowName: wf.name,
+                workflowId: options.workflowId,
+                input: workflowInput,
+                taskQueue: "workflow-tasks",
+                clientConfig,
+                versioningOverride: options.versioningOverride,
+            });
+            // Use Temporal Update to wait for checkpoint (no polling!)
+            // The workflow's update handler blocks until the checkpoint is reached
+            const client = await (0, temporal_client_1.createTemporalClient)(clientConfig);
+            const typedHandle = client.workflow.getHandle(options.workflowId);
+            // Race the update against the configured checkpoint timeout so callers
+            // get a timely error instead of blocking indefinitely when the workflow
+            // never reaches the checkpoint (e.g. a step hangs or fails earlier).
+            const updatePromise = typedHandle.executeUpdate(workflow_factory_1.awaitCheckpointUpdate, {
+                args: [{ checkpointName: options.awaitCheckpoint }],
+            });
+            const partialBag = await new Promise((resolve, reject) => {
+                const timeoutId = setTimeout(() => {
+                    reject(new Error(`Checkpoint "${options.awaitCheckpoint}" for workflow "${wf.name}" ` +
+                        `timed out after ${checkpointTimeoutMs}ms`));
+                }, checkpointTimeoutMs);
+                updatePromise.then((result) => {
+                    clearTimeout(timeoutId);
+                    resolve(result);
+                }, (err) => {
+                    clearTimeout(timeoutId);
+                    reject(err);
+                });
+            });
+            return { bag: partialBag, error: undefined };
+        }
+        // Wait for full workflow completion (existing behavior)
+        const result = await (0, temporal_client_1.executeWorkflowAndWait)({
+            workflowName: wf.name,
+            workflowId: options.workflowId,
+            input: workflowInput,
+            taskQueue: "workflow-tasks",
+            clientConfig,
+        });
+        return result;
+    }
+    catch (err) {
+        // Temporal throws WorkflowFailedError when a workflow exits via ApplicationFailure.
+        // We pack the bag and structured error into ApplicationFailure.details so we can
+        // reconstruct a WorkflowResult here instead of losing the partial bag state.
+        if (err instanceof client_1.WorkflowFailedError && err.cause instanceof client_1.ApplicationFailure) {
+            const detail = err.cause.details?.[0];
+            if (detail) {
+                const errorInfo = detail.error;
+                const error = errorInfo
+                    ? Object.assign(new Error(errorInfo.message), {
+                        code: errorInfo.code,
+                        type: errorInfo.type,
+                        batchNumber: errorInfo.batchNumber,
+                        errors: errorInfo.errors,
+                    })
+                    : new Error(err.message);
+                return { bag: (detail.bag ?? mergedInitialData), error };
+            }
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        return { bag: mergedInitialData, error };
+    }
+}
+/**
+ * Starts a workflow on Temporal without waiting for completion (fire-and-forget).
+ *
+ * Returns the workflowId immediately. The workflow executes in the background
+ * on Temporal workers. Use this for 202 Accepted HTTP responses.
+ *
+ * @param wf - The workflow definition to execute
+ * @param initialData - Initial data for the workflow
+ * @param options - Temporal execution options
+ * @returns The workflowId of the started workflow
+ *
+ * @internal
+ */
+async function startWorkflowTemporal(wf, initialData, options) {
+    // Merge configured values with initial data (like sync path does)
+    const mergedInitialData = {
+        ...initialData,
+        ...(wf.configuredValues ?? {}),
+    };
+    const workflowInput = {
+        initialData: mergedInitialData,
+    };
+    // Use unversioned workflow name -- Temporal Worker Versioning routes to the
+    // correct worker deployment via workerDeploymentOptions.buildId, not the
+    // workflow type name.
+    await (0, temporal_client_1.executeWorkflow)({
+        workflowName: wf.name,
+        workflowId: options.workflowId,
+        input: workflowInput,
+        taskQueue: "workflow-tasks",
+        clientConfig: options.clientConfig,
+        versioningOverride: options.versioningOverride,
+    });
+    return { workflowId: options.workflowId };
+}
+//# sourceMappingURL=workflow-execution.js.map

package/dist/internal/async/execute/workflow-execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-execution.js","sourceRoot":"","sources":["../../../../src/internal/async/execute/workflow-execution.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAiFH,0DAmIC;AAeD,sDA4BC;AA7PD,+CAA6E;AAE7E,+DAIiC;AAGjC,gEAAkE;AAClE,uDAAkG;AAyClG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACI,KAAK,UAAU,uBAAuB,CAC3C,EAA2B,EAC3B,WAAyB,EACzB,OAAiC;IAEjC,kEAAkE;IAClE,2EAA2E;IAC3E,MAAM,iBAAiB,GAAG;QACxB,GAAG,WAAW;QACd,GAAG,CAAC,EAAE,CAAC,gBAAgB,IAAI,EAAE,CAAC;KACf,CAAC;IAElB,IAAI,CAAC;QACH,IAAI,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;QACvE,CAAC;QAED,+EAA+E;QAC/E,IAAI,mBAAuC,CAAC;QAC5C,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;YAC5B,MAAM,UAAU,GAAG,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;YACnF,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,MAAM,UAAU,GAAG,EAAE,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC;gBAC3E,MAAM,IAAI,KAAK,CACb,uBAAuB,OAAO,CAAC,eAAe,mBAAmB,EAAE,CAAC,IAAI,KAAK;oBAC3E,uBAAuB,UAAU,GAAG,CACvC,CAAC;YACJ,CAAC;YACD,mBAAmB,GAAG,UAAU,CAAC,OAAO,IAAI,iDAA6B,CAAC;QAC5E,CAAC;QAED,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QAE1C,MAAM,aAAa,GAAG;YACpB,WAAW,EAAE,iBAAiB;SAC/B,CAAC;QAEF,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,MAAM,IAAA,iCAAe,EAAC;gBACpB,YAAY,EAAE,EAAE,CAAC,IAAI;gBACrB,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,KAAK,EAAE,aAAa;gBACpB,SAAS,EAAE,gBAAgB;gBAC3B,YAAY;aACb,CAAC,CAAC;YAEH,OAAO,EAAE,GAAG,EAAE,iBAAwB,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC7D,CAAC;QAED,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;YAC5B,iDAAiD;YACjD,MAAM,IAAA,iCAAe,EAAC;gBACpB,YAAY,EAAE,EAAE,CAAC,IAAI;gBACrB,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,KAAK,EAAE,aAAa;gBACpB,SAAS,EAAE,gBAAgB;gBAC3B,YAAY;gBACZ,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;aAC/C,CAAC,CAAC;YAEH,2DAA2D;YAC3D,uEAAuE;YACvE,MAAM,MAAM,GAAG,MAAM,IAAA,sCAAoB,EAAC,YAAY,CAAC,CAAC;YACxD,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAElE,uEAAuE;YACvE,wEAAwE;YACxE,qEAAqE;YACrE,MAAM,aAAa,GAAG,WAAW,CAAC,aAAa,CAAC,wCAAqB,EAAE;gBACrE,IAAI,EAAE,CAAC,EAAE,cAAc,EAAE,OAAO,CAAC,eAAe,EAAE,CAAC;aACpD,CAAC,CAAC;YAEH,MAAM,UAAU,GAAG,MAAM,IAAI,OAAO,CAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBAChF,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;oBAChC,MAAM,CACJ,IAAI,KAAK,CACP,eAAe,OAAO,CAAC,eAAe,mBAAmB,EAAE,CAAC,IAAI,IAAI;wBAClE,mBAAmB,mBAAmB,IAAI,CAC7C,CACF,CAAC;gBACJ,CAAC,EAAE,mBAAmB,CAAC,CAAC;gBAExB,aAAa,CAAC,IAAI,CAChB,CAAC,MAAM,EAAE,EAAE;oBACT,YAAY,CAAC,SAAS,CAAC,CAAC;oBACxB,OAAO,CAAC,MAAM,CAAC,CAAC;gBAClB,CAAC,EACD,CAAC,GAAG,EAAE,EAAE;oBACN,YAAY,CAAC,SAAS,CAAC,CAAC;oBACxB,MAAM,CAAC,GAAG,CAAC,CAAC;gBACd,CAAC,CACF,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,OAAO,EAAE,GAAG,EAAE,UAAiB,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QACtD,CAAC;QAED,wDAAwD;QACxD,MAAM,MAAM,GAAG,MAAM,IAAA,wCAAsB,EAAC;YAC1C,YAAY,EAAE,EAAE,CAAC,IAAI;YACrB,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,KAAK,EAAE,aAAa;YACpB,SAAS,EAAE,gBAAgB;YAC3B,YAAY;SACb,CAAC,CAAC;QAEH,OAAO,MAA6B,CAAC;IACvC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,oFAAoF;QACpF,iFAAiF;QACjF,6EAA6E;QAC7E,IAAI,GAAG,YAAY,4BAAmB,IAAI,GAAG,CAAC,KAAK,YAAY,2BAAkB,EAAE,CAAC;YAClF,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAEvB,CAAC;YACd,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;gBAC/B,MAAM,KAAK,GAAG,SAAS;oBACrB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE;wBAC1C,IAAI,EAAE,SAAS,CAAC,IAAI;wBACpB,IAAI,EAAE,SAAS,CAAC,IAAI;wBACpB,WAAW,EAAE,SAAS,CAAC,WAAW;wBAClC,MAAM,EAAE,SAAS,CAAC,MAAM;qBACzB,CAAC;oBACJ,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC3B,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,GAAG,IAAI,iBAAiB,CAAQ,EAAE,KAAK,EAAE,CAAC;YAClE,CAAC;QACH,CAAC;QACD,MAAM,KAAK,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QAClE,OAAO,EAAE,GAAG,EAAE,iBAAwB,EAAE,KAAK,EAAE,CAAC;IAClD,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACI,KAAK,UAAU,qBAAqB,CACzC,EAA2B,EAC3B,WAAyB,EACzB,OAA6F;IAE7F,kEAAkE;IAClE,MAAM,iBAAiB,GAAG;QACxB,GAAG,WAAW;QACd,GAAG,CAAC,EAAE,CAAC,gBAAgB,IAAI,EAAE,CAAC;KACf,CAAC;IAElB,MAAM,aAAa,GAAG;QACpB,WAAW,EAAE,iBAAiB;KAC/B,CAAC;IAEF,4EAA4E;IAC5E,yEAAyE;IACzE,sBAAsB;IACtB,MAAM,IAAA,iCAAe,EAAC;QACpB,YAAY,EAAE,EAAE,CAAC,IAAI;QACrB,UAAU,EAAE,OAAO,CAAC,UAAU;QAC9B,KAAK,EAAE,aAAa;QACpB,SAAS,EAAE,gBAAgB;QAC3B,YAAY,EAAE,OAAO,CAAC,YAAY;QAClC,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;KAC/C,CAAC,CAAC;IAEH,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC;AAC5C,CAAC"}

package/dist/internal/async/metrics/task-queue-metrics.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Temporal Task Queue Metrics Publisher
+ *
+ * Each activity worker container can poll one or more Temporal task queues and
+ * emits CloudWatch metrics used by ECS autoscaling. The two published metrics
+ * look similar at first glance because they share the same queue dimensions,
+ * but they represent different kinds of truth and therefore must be aggregated
+ * differently:
+ *
+ * 1. TaskQueueBacklogCount -- queue-level state from DescribeTaskQueue.
+ *    This answers "how many activity tasks are waiting in queue X right now?"
+ *    That answer belongs to the queue itself, not to any specific container.
+ *    If five containers all poll "standard-tasks", they will all observe the
+ *    same backlog value and all publish, for example, "12" for the same
+ *    CloudWatch dimensions. Those five samples are duplicate observations of
+ *    one queue, not five separate chunks of work. Consumers therefore must
+ *    read backlog per queue with the Maximum statistic, which preserves the
+ *    true queue backlog of 12 instead of accidentally treating it like 60.
+ *    Once each queue has been reduced to its true backlog, autoscaling can sum
+ *    across distinct queues to answer "how much pending work does this ECS
+ *    service need to handle overall?"
+ *
+ * 2. RunningActivitiesCount -- container-level state for this process.
+ *    This answers "how many activity tasks is this container executing right
+ *    now?" The counter is process-wide and does not care which polled queue
+ *    each activity originally came from. If one container is polling both
+ *    "standard-tasks" and "heavy-tasks" and currently has 7 running
+ *    activities total, this publisher emits:
+ *
+ *      RunningActivitiesCount{TaskQueue="standard-tasks"} = 7
+ *      RunningActivitiesCount{TaskQueue="heavy-tasks"} = 7
+ *
+ *    Those are not two independent groups of 7 running tasks. They are the
+ *    same process-wide total written under two queue labels so that each polled
+ *    queue has a metric stream. Consumers therefore must NOT sum running count
+ *    across all queue dimensions for a multi-queue worker, or that one
+ *    container would be double-counted. Instead, autoscaling must choose one
+ *    canonical queue dimension for the service (the primary queue) and sum
+ *    RunningActivitiesCount across containers only within that single
+ *    dimension. That produces the real fleet-wide in-flight activity count
+ *    without inflating totals for workers that poll absorbed fallback queues.
+ */
+import { CloudWatchClient } from "@aws-sdk/client-cloudwatch";
+import type { NativeConnection } from "@temporalio/worker";
+import type { ComposerLogger } from "../../types";
+export interface TaskQueueMetricsConfig {
+    connection: NativeConnection;
+    taskQueues: string[];
+    temporalNamespace: string;
+    logger: ComposerLogger;
+    /** Environment name used as a CloudWatch dimension to avoid collisions. */
+    environmentName?: string;
+    /** CloudWatch publishing interval in ms. Defaults to 60000 (60s). */
+    pollIntervalMs?: number;
+    /** CloudWatch metric namespace. Defaults to "Composer". */
+    cloudWatchNamespace?: string;
+    /** Injected for testing. Defaults to a real CloudWatchClient. */
+    cloudWatchClient?: CloudWatchClient;
+}
+export interface TaskQueueMetricsHandle {
+    /** Stop the polling loop and clean up. */
+    stop: () => void;
+    /** Report that an activity started on this container. */
+    activityStarted: () => void;
+    /** Report that an activity finished on this container. */
+    activityFinished: () => void;
+}
+/**
+ * Starts a background polling loop that publishes task queue metrics to CloudWatch.
+ *
+ * Returns a handle to stop the loop and to track running activity count.
+ */
+export declare function startTaskQueueMetrics(config: TaskQueueMetricsConfig): TaskQueueMetricsHandle;
+//# sourceMappingURL=task-queue-metrics.d.ts.map

package/dist/internal/async/metrics/task-queue-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-queue-metrics.d.ts","sourceRoot":"","sources":["../../../../src/internal/async/metrics/task-queue-metrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EACL,gBAAgB,EAIjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAUlD,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,cAAc,CAAC;IACvB,2EAA2E;IAC3E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,yDAAyD;IACzD,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,0DAA0D;IAC1D,gBAAgB,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,sBAAsB,GAAG,sBAAsB,CAyH5F"}

package/dist/internal/async/metrics/task-queue-metrics.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * Temporal Task Queue Metrics Publisher
+ *
+ * Each activity worker container can poll one or more Temporal task queues and
+ * emits CloudWatch metrics used by ECS autoscaling. The two published metrics
+ * look similar at first glance because they share the same queue dimensions,
+ * but they represent different kinds of truth and therefore must be aggregated
+ * differently:
+ *
+ * 1. TaskQueueBacklogCount -- queue-level state from DescribeTaskQueue.
+ *    This answers "how many activity tasks are waiting in queue X right now?"
+ *    That answer belongs to the queue itself, not to any specific container.
+ *    If five containers all poll "standard-tasks", they will all observe the
+ *    same backlog value and all publish, for example, "12" for the same
+ *    CloudWatch dimensions. Those five samples are duplicate observations of
+ *    one queue, not five separate chunks of work. Consumers therefore must
+ *    read backlog per queue with the Maximum statistic, which preserves the
+ *    true queue backlog of 12 instead of accidentally treating it like 60.
+ *    Once each queue has been reduced to its true backlog, autoscaling can sum
+ *    across distinct queues to answer "how much pending work does this ECS
+ *    service need to handle overall?"
+ *
+ * 2. RunningActivitiesCount -- container-level state for this process.
+ *    This answers "how many activity tasks is this container executing right
+ *    now?" The counter is process-wide and does not care which polled queue
+ *    each activity originally came from. If one container is polling both
+ *    "standard-tasks" and "heavy-tasks" and currently has 7 running
+ *    activities total, this publisher emits:
+ *
+ *      RunningActivitiesCount{TaskQueue="standard-tasks"} = 7
+ *      RunningActivitiesCount{TaskQueue="heavy-tasks"} = 7
+ *
+ *    Those are not two independent groups of 7 running tasks. They are the
+ *    same process-wide total written under two queue labels so that each polled
+ *    queue has a metric stream. Consumers therefore must NOT sum running count
+ *    across all queue dimensions for a multi-queue worker, or that one
+ *    container would be double-counted. Instead, autoscaling must choose one
+ *    canonical queue dimension for the service (the primary queue) and sum
+ *    RunningActivitiesCount across containers only within that single
+ *    dimension. That produces the real fleet-wide in-flight activity count
+ *    without inflating totals for workers that poll absorbed fallback queues.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTaskQueueMetrics = startTaskQueueMetrics;
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const DEFAULT_CLOUDWATCH_NAMESPACE = "Composer";
+const DEFAULT_POLL_INTERVAL_MS = 60_000;
+function getNextPublishTimestampMs(nowMs, intervalMs) {
+    const remainder = nowMs % intervalMs;
+    return remainder === 0 ? nowMs + intervalMs : nowMs + (intervalMs - remainder);
+}
+/**
+ * Starts a background polling loop that publishes task queue metrics to CloudWatch.
+ *
+ * Returns a handle to stop the loop and to track running activity count.
+ */
+function startTaskQueueMetrics(config) {
+    const { connection, taskQueues, temporalNamespace, environmentName = process.env.ENVIRONMENT_NAME ?? "unknown", logger, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, cloudWatchNamespace = DEFAULT_CLOUDWATCH_NAMESPACE, cloudWatchClient = new client_cloudwatch_1.CloudWatchClient({}), } = config;
+    let runningActivities = 0;
+    let stopped = false;
+    let timer;
+    let nextPublishTimestampMs = getNextPublishTimestampMs(Date.now(), pollIntervalMs);
+    const scheduleNextPublish = () => {
+        if (stopped)
+            return;
+        const nowMs = Date.now();
+        while (nextPublishTimestampMs <= nowMs) {
+            nextPublishTimestampMs += pollIntervalMs;
+        }
+        timer = setTimeout(() => {
+            const publishTimestampMs = nextPublishTimestampMs;
+            nextPublishTimestampMs += pollIntervalMs;
+            void publishMetrics(new Date(publishTimestampMs));
+        }, nextPublishTimestampMs - nowMs);
+        timer.unref();
+    };
+    const publishMetrics = async (timestamp) => {
+        if (stopped)
+            return;
+        try {
+            const metricData = [];
+            for (const taskQueue of taskQueues) {
+                const dimensions = [
+                    { Name: "TaskQueue", Value: taskQueue },
+                    { Name: "TemporalNamespace", Value: temporalNamespace },
+                    { Name: "Environment", Value: environmentName },
+                ];
+                let backlogCount = 0;
+                try {
+                    const response = await connection.workflowService.describeTaskQueue({
+                        namespace: temporalNamespace,
+                        taskQueue: { name: taskQueue },
+                        taskQueueType: 2,
+                        reportStats: true,
+                    });
+                    backlogCount = Number(response.stats?.approximateBacklogCount ?? 0);
+                }
+                catch (error) {
+                    logger.warn("Failed to describe task queue", {
+                        taskQueue,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                metricData.push({
+                    MetricName: "TaskQueueBacklogCount",
+                    Dimensions: dimensions,
+                    Value: backlogCount,
+                    Unit: client_cloudwatch_1.StandardUnit.Count,
+                    Timestamp: timestamp,
+                }, {
+                    MetricName: "RunningActivitiesCount",
+                    Dimensions: dimensions,
+                    Value: runningActivities,
+                    Unit: client_cloudwatch_1.StandardUnit.Count,
+                    Timestamp: timestamp,
+                });
+            }
+            if (metricData.length > 0) {
+                await cloudWatchClient.send(new client_cloudwatch_1.PutMetricDataCommand({
+                    Namespace: cloudWatchNamespace,
+                    MetricData: metricData,
+                }));
+            }
+        }
+        catch (error) {
+            logger.warn("Failed to publish task queue metrics", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        scheduleNextPublish();
+    };
+    scheduleNextPublish();
+    logger.info("Task queue metrics poller started", {
+        taskQueues,
+        temporalNamespace,
+        pollIntervalMs,
+    });
+    return {
+        stop: () => {
+            stopped = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            logger.info("Task queue metrics poller stopped");
+        },
+        activityStarted: () => {
+            runningActivities++;
+        },
+        activityFinished: () => {
+            runningActivities = Math.max(0, runningActivities - 1);
+        },
+    };
+}
+//# sourceMappingURL=task-queue-metrics.js.map

package/dist/internal/async/metrics/task-queue-metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-queue-metrics.js","sourceRoot":"","sources":["../../../../src/internal/async/metrics/task-queue-metrics.ts"],"names":[],"mappings":"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"}

package/dist/internal/async/register/activity-worker.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Temporal Activity Worker
+ *
+ * Registers and executes step business logic as Temporal activities.
+ * Accepts workflow definitions declaratively and extracts steps from them.
+ *
+ * ## Activity Worker Responsibilities:
+ * - Connect to Temporal Server
+ * - Extract step definitions from provided workflow objects
+ * - Create Temporal activities from steps
+ * - Create wrapper activities for error handlers and FanOut operations
+ * - Register activities with appropriate task queues (fast/standard/heavy)
+ * - Execute business logic directly (steps handle their own dependencies)
+ *
+ * ## What Activities CAN Do (unlike workflows):
+ * - Access Node.js APIs (fs, http, process, etc.)
+ * - Make database queries
+ * - Call external APIs
+ * - Use non-deterministic functions
+ * - Import and execute business logic
+ *
+ * ## Step Execution Model:
+ * Steps are pure business logic that receive only their declared inputs (bag fields).
+ * Steps obtain their own dependencies (e.g., IxDbConnection.getInstance()).
+ * The workflow engine handles all observability automatically.
+ *
+ * @module activity-worker
+ */
+import { NativeConnection, Worker } from "@temporalio/worker";
+import type { StepContextProvider } from "../../context-provider";
+import type { Workflow } from "../../dag-sync-workflow";
+import type { ComposerLogger } from "../../types";
+import { type TaskQueueMetricsHandle } from "../metrics/task-queue-metrics";
+/**
+ * Configuration for the Activity Worker.
+ * All fields are required - callers must provide complete configuration.
+ *
+ * @typeParam TContext - The context type provided to steps
+ */
+export interface ActivityWorkerConfig<TContext = unknown> {
+    /**
+     * Temporal Server address (e.g., "localhost:7233" for local dev)
+     */
+    serverAddress: string;
+    /**
+     * Temporal namespace to connect to
+     */
+    namespace: string;
+    /**
+     * Deployment series name for Worker Versioning (e.g., "orders-service-activities").
+     * Derived from the service name via getDeploymentSeriesNames().
+     */
+    deploymentSeriesName: string;
+    /**
+     * Build identifier for Worker Versioning (typically git commit SHA).
+     * When set, workers register with this buildId for version-aware routing.
+     * When unset, Worker Versioning is disabled.
+     */
+    buildId?: string;
+    /**
+     * Task queues to listen on for activity tasks.
+     * Activities are routed to queues based on their workerProfile.
+     */
+    taskQueues: string[];
+    /**
+     * Maximum number of concurrent activity executions per queue
+     */
+    maxConcurrentActivityTaskExecutions: number;
+    /**
+     * Context provider for step execution.
+     * If provided, beforeStep/afterStep hooks will be called for each activity.
+     */
+    contextProvider?: StepContextProvider<TContext>;
+    /**
+     * Workflow definitions to register.
+     * Steps are extracted from each workflow's .steps array.
+     * Error handlers and FanOut wrappers are derived from the workflows.
+     */
+    workflows: Workflow<any, any, any>[];
+    /**
+     * Logger for worker lifecycle and activity execution messages.
+     * If not provided, defaults to the console-based defaultLogger.
+     */
+    logger?: ComposerLogger;
+}
+/**
+ * Creates Temporal Activity Workers with automatic connection management.
+ *
+ * Extracts steps from the provided workflow definitions, creates activity
+ * functions, and registers them with Temporal workers for the specified
+ * task queues.
+ *
+ * @param config - Worker configuration
+ * @returns Object containing workers array and the created connection
+ */
+export declare function createActivityWorkers<TContext = unknown>(config: ActivityWorkerConfig<TContext>): Promise<{
+    workers: Worker[];
+    connection: NativeConnection;
+    metricsHandle?: TaskQueueMetricsHandle;
+}>;
+/**
+ * Starts Activity Workers and runs them until interrupted.
+ *
+ * Creates a Temporal connection, initializes workers with loaded step implementations,
+ * and handles graceful shutdown on SIGINT/SIGTERM. The connection is automatically
+ * managed and closed on shutdown.
+ *
+ * @param config - Worker configuration
+ *
+ * @example
+ * ```typescript
+ * // Run activity workers (blocks until interrupted)
+ * await runActivityWorkers({
+ *   serverAddress: "localhost:7233",
+ *   namespace: "default",
+ *   taskQueues: ["workflow-tasks"],
+ *   maxConcurrentActivityTaskExecutions: 10,
+ *   workflows: [myWorkflow],
+ * });
+ * ```
+ */
+export declare function runActivityWorkers<TContext = unknown>(config: ActivityWorkerConfig<TContext>): Promise<void>;
+//# sourceMappingURL=activity-worker.d.ts.map