@acmekit/orchestration 2.13.36 → 2.13.38

package/dist/transaction/transaction-orchestrator.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionOrchestrator = void 0;
 const ulid_1 = require("ulid");
-const circuit_breaker_1 = require("./circuit-breaker");
 const distributed_transaction_1 = require("./distributed-transaction");
 const transaction_step_1 = require("./transaction-step");
 const types_1 = require("./types");
 const utils_1 = require("@acmekit/utils");
 const events_1 = require("events");
 const errors_1 = require("./errors");
+const workflow_manager_1 = require("../workflow/workflow-manager");
 const canMoveForwardStates = new Set([
     utils_1.TransactionStepState.DONE,
     utils_1.TransactionStepState.FAILED,
@@ -40,56 +40,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
     static getWorkflowOptions(modelId) {
         return TransactionOrchestrator.workflowOptions[modelId];
     }
-    static appendAuditEntry(transaction, event, step, extra) {
-        const store = TransactionOrchestrator.auditLogStore;
-        if (!store) {
-            return;
-        }
-        const flow = transaction.getFlow();
-        if (!flow.options?.auditLog) {
-            return;
-        }
-        const entry = {
-            id: (0, ulid_1.ulid)(),
-            timestamp: Date.now(),
-            event,
-            workflowId: flow.modelId,
-            transactionId: flow.transactionId,
-            stepId: step?.id,
-            stepAction: step?.definition.action,
-            handlerType: step
-                ? step.isCompensating()
-                    ? "compensate"
-                    : "invoke"
-                : undefined,
-            attempt: step?.attempts,
-            ...extra,
-        };
-        // Fire-and-forget; don't block the transaction
-        void Promise.resolve(store.append(entry)).catch(() => { });
-    }
-    /**
-     * Compute a simple hash of a workflow definition for version tracking.
-     * This uses the action names and their order as the version fingerprint.
-     */
-    static computeDefinitionHash(definition) {
-        const actions = [];
-        const queue = [definition];
-        while (queue.length > 0) {
-            const node = queue.shift();
-            if (node.action) {
-                actions.push(node.action);
-            }
-            if (Array.isArray(node.next)) {
-                queue.push(...node.next);
-            }
-            else if (node.next && (0, utils_1.isObject)(node.next)) {
-                queue.push(node.next);
-            }
-        }
-        // Simple hash: join action names. This is deterministic and fast.
-        return actions.join("|");
-    }
     constructor({ id, definition, options, isClone, }) {
         super();
         this.invokeSteps = [];
@@ -218,7 +168,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             flow.state = types_1.TransactionState.COMPENSATING;
             this.flagStepsToRevert(flow);
             this.emit(types_1.DistributedTransactionEvent.COMPENSATE_BEGIN, { transaction });
-            TransactionOrchestrator.appendAuditEntry(transaction, types_1.DistributedTransactionEvent.COMPENSATE_BEGIN);
             const result = await this.checkAllSteps(transaction);
             return result;
         }
@@ -373,6 +322,16 @@ class TransactionOrchestrator extends events_1.EventEmitter {
     }
     static async setStepSuccess(transaction, step, response) {
         const hasStepTimedOut = step.getStates().state === utils_1.TransactionStepState.TIMEOUT;
+        // Clear signal index entry when a signal step resolves
+        if (step.definition.signal && !step.isCompensating()) {
+            const sig = step.definition.signal;
+            const flow = transaction.getFlow();
+            workflow_manager_1.WorkflowManager.clearSignalIndex(flow.modelId, sig.name, sig.key);
+            // Remove from flow's signalRegistry
+            if (flow.signalRegistry) {
+                delete flow.signalRegistry[sig.name];
+            }
+        }
         if (step.saveResponse) {
             transaction.addResponse(step.definition.action, step.isCompensating()
                 ? types_1.TransactionHandlerType.COMPENSATE
@@ -419,25 +378,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 ? types_1.DistributedTransactionEvent.COMPENSATE_STEP_SUCCESS
                 : types_1.DistributedTransactionEvent.STEP_SUCCESS;
             transaction.emit(eventName, { step, transaction });
-            const durationMs = step.startedAt
-                ? Date.now() - step.startedAt
-                : undefined;
-            TransactionOrchestrator.appendAuditEntry(transaction, eventName, step, { durationMs });
-            if (TransactionOrchestrator.metricsCollector) {
-                const now = Date.now();
-                TransactionOrchestrator.metricsCollector.recordStepMetrics({
-                    workflowId: transaction.getFlow().modelId,
-                    transactionId: transaction.getFlow().transactionId,
-                    stepId: step.id,
-                    action: step.definition.action,
-                    type: step.isCompensating() ? "compensate" : "invoke",
-                    status: "success",
-                    attempt: step.attempts,
-                    startedAt: step.startedAt ?? now,
-                    completedAt: now,
-                    durationMs: durationMs ?? 0,
-                });
-            }
         }
         return {
             stopExecution: !shouldEmit,
@@ -502,22 +442,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         if (shouldEmit) {
             const eventName = types_1.DistributedTransactionEvent.STEP_SKIPPED;
             transaction.emit(eventName, { step, transaction });
-            TransactionOrchestrator.appendAuditEntry(transaction, eventName, step);
-            if (TransactionOrchestrator.metricsCollector) {
-                const now = Date.now();
-                TransactionOrchestrator.metricsCollector.recordStepMetrics({
-                    workflowId: transaction.getFlow().modelId,
-                    transactionId: transaction.getFlow().transactionId,
-                    stepId: step.id,
-                    action: step.definition.action,
-                    type: step.isCompensating() ? "compensate" : "invoke",
-                    status: "skipped",
-                    attempt: step.attempts,
-                    startedAt: step.startedAt ?? now,
-                    completedAt: now,
-                    durationMs: step.startedAt ? now - step.startedAt : 0,
-                });
-            }
         }
         return {
             stopExecution: !shouldEmit,
@@ -551,12 +475,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             return result;
         }
         step.failures++;
-        // Record circuit breaker failure
-        const cbConfig = step.definition.circuitBreaker;
-        if (cbConfig && TransactionOrchestrator.circuitBreaker) {
-            const cbKey = `${transaction.getFlow().modelId}:${step.definition.action}`;
-            void Promise.resolve(TransactionOrchestrator.circuitBreaker.recordFailure(cbKey, cbConfig)).catch(() => { });
-        }
         if ((0, utils_1.isErrorLike)(error)) {
             error = (0, utils_1.serializeError)(error);
         }
@@ -667,31 +585,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 ? types_1.DistributedTransactionEvent.COMPENSATE_STEP_FAILURE
                 : types_1.DistributedTransactionEvent.STEP_FAILURE;
             transaction.emit(eventName, { step, transaction });
-            const durationMs = step.startedAt
-                ? Date.now() - step.startedAt
-                : undefined;
-            TransactionOrchestrator.appendAuditEntry(transaction, eventName, step, {
-                durationMs,
-                errorMessage: (0, utils_1.isErrorLike)(error)
-                    ? error.message
-                    : String(error?.message ?? "Unknown error"),
-            });
-            if (TransactionOrchestrator.metricsCollector &&
-                step.getStates().status === types_1.TransactionStepStatus.PERMANENT_FAILURE) {
-                const now = Date.now();
-                TransactionOrchestrator.metricsCollector.recordStepMetrics({
-                    workflowId: transaction.getFlow().modelId,
-                    transactionId: transaction.getFlow().transactionId,
-                    stepId: step.id,
-                    action: step.definition.action,
-                    type: step.isCompensating() ? "compensate" : "invoke",
-                    status: isTimeout ? "timeout" : "failure",
-                    attempt: step.attempts,
-                    startedAt: step.startedAt ?? now,
-                    completedAt: now,
-                    durationMs: durationMs ?? 0,
-                });
-            }
         }
         return {
             stopExecution: result.stopExecution,
@@ -755,7 +648,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                     step,
                     transaction,
                 });
-                TransactionOrchestrator.appendAuditEntry(transaction, types_1.DistributedTransactionEvent.STEP_BEGIN, step);
                 const isAsync = step.isCompensating()
                     ? step.definition.compensateAsync
                     : step.definition.async;
@@ -799,57 +691,56 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         if (transaction.hasTimeout()) {
             void transaction.clearTransactionTimeout();
         }
+        // Clean up signal and query index entries for this transaction
+        TransactionOrchestrator.cleanupSignalAndQueryIndex(transaction);
         await transaction.saveCheckpoint().catch((error) => {
             if (!TransactionOrchestrator.isExpectedError(error)) {
                 throw error;
             }
         });
         this.emit(types_1.DistributedTransactionEvent.FINISH, { transaction });
-        TransactionOrchestrator.appendAuditEntry(transaction, types_1.DistributedTransactionEvent.FINISH);
-        if (TransactionOrchestrator.metricsCollector) {
-            const flow = transaction.getFlow();
-            const now = Date.now();
-            const steps = Object.values(flow.steps).filter((s) => s.id !== TransactionOrchestrator.ROOT_STEP);
-            const stepMetricsList = [];
-            for (const s of steps) {
-                if (s.startedAt) {
-                    stepMetricsList.push({
-                        workflowId: flow.modelId,
-                        transactionId: flow.transactionId,
-                        stepId: s.id,
-                        action: s.definition.action,
-                        type: s.isCompensating() ? "compensate" : "invoke",
-                        status: s.getStates().state === utils_1.TransactionStepState.SKIPPED
-                            ? "skipped"
-                            : s.getStates().state === utils_1.TransactionStepState.TIMEOUT
-                                ? "timeout"
-                                : s.getStates().state === utils_1.TransactionStepState.FAILED
-                                    ? "failure"
-                                    : "success",
-                        attempt: s.attempts,
-                        startedAt: s.startedAt,
-                        completedAt: now,
-                        durationMs: now - s.startedAt,
-                    });
-                }
+    }
+    /**
+     * Clean up all signal and query index entries for a transaction.
+     */
+    static cleanupSignalAndQueryIndex(transaction) {
+        const flow = transaction.getFlow();
+        // Clean up signal index entries
+        if (flow.signalRegistry) {
+            for (const [signalName, _stepAction] of Object.entries(flow.signalRegistry)) {
+                const step = TransactionOrchestrator.getStepByAction(flow, _stepAction);
+                const key = step?.definition.signal?.key;
+                workflow_manager_1.WorkflowManager.clearSignalIndex(flow.modelId, signalName, key);
             }
-            const workflowMetrics = {
-                workflowId: flow.modelId,
-                transactionId: flow.transactionId,
-                status: flow.state === types_1.TransactionState.DONE
-                    ? "done"
-                    : flow.state === types_1.TransactionState.REVERTED
-                        ? "reverted"
-                        : "failed",
-                startedAt: flow.startedAt ?? now,
-                completedAt: now,
-                totalDurationMs: flow.startedAt ? now - flow.startedAt : 0,
-                stepCount: steps.length,
-                compensationCount: steps.filter((s) => s.isCompensating()).length,
-                retryTotal: steps.reduce((sum, s) => sum + Math.max(0, s.attempts - 1), 0),
-                steps: stepMetricsList,
-            };
-            TransactionOrchestrator.metricsCollector.recordWorkflowMetrics(workflowMetrics);
+        }
+        // Clean up query index entries
+        if (flow.queryHandlers) {
+            for (const [queryName, meta] of Object.entries(flow.queryHandlers)) {
+                workflow_manager_1.WorkflowManager.clearQueryIndex(flow.modelId, queryName, meta.key);
+            }
+        }
+    }
+    /**
+     * Parse a duration string like "30s", "5m", "1h", "7d" into seconds.
+     */
+    static parseDurationToSeconds(input) {
+        const match = input.match(TransactionOrchestrator.DURATION_RE);
+        if (!match) {
+            throw new Error(`Invalid duration format: "${input}". Expected format: "<number>s", "<number>m", "<number>h", or "<number>d".`);
+        }
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        switch (unit) {
+            case "s":
+                return value;
+            case "m":
+                return value * 60;
+            case "h":
+                return value * 60 * 60;
+            case "d":
+                return value * 60 * 60 * 24;
+            default:
+                throw new Error(`Unknown duration unit: "${unit}"`);
         }
     }
     /**
@@ -925,29 +816,8 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 : step.definition.compensateAsync),
             idempotency_key: handlerArgs[2].metadata.idempotency_key,
         };
-        const cbConfig = step.definition.circuitBreaker;
-        const cbKey = cbConfig
-            ? `${flow.modelId}:${step.definition.action}`
-            : undefined;
         const stepHandler = async () => {
-            // Check circuit breaker before execution
-            if (cbConfig && cbKey) {
-                const cb = TransactionOrchestrator.circuitBreaker ??
-                    (TransactionOrchestrator.circuitBreaker =
-                        new circuit_breaker_1.InMemoryCircuitBreaker());
-                const state = typeof cb.maybeTransition === "function"
-                    ? cb.maybeTransition(cbKey, cbConfig)
-                    : await cb.getState(cbKey);
-                if (state === "open") {
-                    throw new errors_1.CircuitOpenError(step.definition.action);
-                }
-            }
-            const result = await transaction.handler(...handlerArgs);
-            // Record circuit breaker success
-            if (cbConfig && cbKey && TransactionOrchestrator.circuitBreaker) {
-                void Promise.resolve(TransactionOrchestrator.circuitBreaker.recordSuccess(cbKey)).catch(() => { });
-            }
-            return result;
+            return await transaction.handler(...handlerArgs);
         };
         // Return the appropriate promise based on tracing configuration
         if (TransactionOrchestrator.traceStep) {
@@ -1095,31 +965,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         if (transaction.hasFinished()) {
             return;
         }
-        // Version checking and migration (4.5.1 / 4.5.2)
-        const flow = transaction.getFlow();
-        const storedVersion = flow.workflowVersion;
-        const currentVersion = TransactionOrchestrator.computeDefinitionHash(this.definition);
-        if (storedVersion && storedVersion !== currentVersion) {
-            const policy = this.options?.versionPolicy ?? "lenient";
-            // Try to apply migrations first
-            if (this.options?.migrations?.length) {
-                let version = storedVersion;
-                for (const migration of this.options.migrations) {
-                    if (migration.fromVersion === version) {
-                        migration.migrate(flow);
-                        version = migration.toVersion;
-                    }
-                }
-                flow.workflowVersion = version;
-            }
-            // After migrations, check again
-            const afterMigrationVersion = flow.workflowVersion ?? storedVersion;
-            if (afterMigrationVersion !== currentVersion && policy === "strict") {
-                throw new errors_1.WorkflowVersionMismatchError(currentVersion, afterMigrationVersion);
-            }
-            // Update version to current for lenient mode
-            flow.workflowVersion = currentVersion;
-        }
         const executeNext = async () => {
             const flow = transaction.getFlow();
             if (flow.state === types_1.TransactionState.NOT_STARTED) {
@@ -1132,11 +977,9 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                     await transaction.scheduleTransactionTimeout(transaction.getTimeout());
                 }
                 this.emit(types_1.DistributedTransactionEvent.BEGIN, { transaction });
-                TransactionOrchestrator.appendAuditEntry(transaction, types_1.DistributedTransactionEvent.BEGIN);
             }
             else {
                 this.emit(types_1.DistributedTransactionEvent.RESUME, { transaction });
-                TransactionOrchestrator.appendAuditEntry(transaction, types_1.DistributedTransactionEvent.RESUME);
             }
             return await this.executeNext(transaction);
         };
@@ -1169,9 +1012,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         }
         flow.state = types_1.TransactionState.WAITING_TO_COMPENSATE;
         flow.cancelledAt = Date.now();
-        if (options?.reason) {
-            flow.cancelReason = options.reason;
-        }
         await transaction.saveCheckpoint();
         if (options?.preventExecuteNext) {
             return;
@@ -1211,6 +1051,7 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             transactionId: transactionId,
             runId: context?.runId ?? (0, ulid_1.ulid)(),
             metadata: flowMetadata,
+            customMetadata: flowMetadata?.customMetadata,
             hasAsyncSteps: features.hasAsyncSteps,
             hasFailedSteps: false,
             hasSkippedOnFailureSteps: false,
@@ -1222,7 +1063,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             definition: this.definition,
             steps,
             _v: 0, // Initialize version to 0
-            workflowVersion: TransactionOrchestrator.computeDefinitionHash(this.definition),
         };
         return flow;
     }
@@ -1268,6 +1108,21 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 }
                 const definitionCopy = { ...obj };
                 delete definitionCopy.next;
+                // Signal steps are implicitly async
+                if (definitionCopy.signal && !definitionCopy.async) {
+                    definitionCopy.async = true;
+                }
+                // Signal steps with timeout: convert duration strings to seconds
+                if (definitionCopy.signal?.timeout && !definitionCopy.timeout) {
+                    const t = definitionCopy.signal.timeout;
+                    if (typeof t === "string") {
+                        definitionCopy.timeout =
+                            TransactionOrchestrator.parseDurationToSeconds(t);
+                    }
+                    else {
+                        definitionCopy.timeout = t;
+                    }
+                }
                 const isAsync = !!definitionCopy.async;
                 const hasRetryInterval = !!(definitionCopy.retryInterval || definitionCopy.retryIntervalAwaiting);
                 const hasTimeout = !!definitionCopy.timeout;
@@ -1333,13 +1188,6 @@ class TransactionOrchestrator extends events_1.EventEmitter {
      * @param flowMetadata - flow metadata which can include event group id for example
      */
     async beginTransaction({ transactionId, handler, payload, flowMetadata, context, onLoad, }) {
-        // Check rate limit for new transactions
-        if (this.options?.rateLimit && TransactionOrchestrator.rateLimiter) {
-            const allowed = await TransactionOrchestrator.rateLimiter.acquire(this.id, this.options.rateLimit);
-            if (!allowed) {
-                throw new errors_1.RateLimitExceededError(this.id);
-            }
-        }
         const existingTransaction = await TransactionOrchestrator.loadTransactionById(this.id, transactionId);
         let newTransaction = false;
         let modelFlow;
@@ -1513,4 +1361,5 @@ TransactionOrchestrator.DEFAULT_TTL = 30;
 TransactionOrchestrator.DEFAULT_RETRIES = 0;
 TransactionOrchestrator.workflowOptions = {};
 TransactionOrchestrator.SEPARATOR = ":";
+TransactionOrchestrator.DURATION_RE = /^(\d+)(s|m|h|d)$/;
 //# sourceMappingURL=transaction-orchestrator.js.map