@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/workflows/workflow-executor.js

@@ -0,0 +1,1186 @@
+"use strict";
+/**
+ * WorkflowExecutor - Executes workflow steps and manages rollbacks
+ *
+ * Handles the actual execution of workflow steps, including:
+ * - Processing each step type (action, database, notification, etc.)
+ * - Managing rollback on failure
+ * - Tracking workflow state and completed steps
+ * - Handling signals and checkpoints
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowExecutor = void 0;
+const crypto_1 = require("crypto");
+const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const processorApi_service_1 = require("../api/services/processorApi.service");
+const workflowApi_service_1 = require("../api/services/workflowApi.service");
+const graph_1 = require("../graph");
+const database_1 = require("../database");
+const resilience_1 = require("../resilience");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const types_1 = require("../types");
+/**
+ * WorkflowExecutor handles the execution of workflow steps
+ */
+class WorkflowExecutor {
+    constructor(config, workflow, options, sessionLogFields) {
+        this.productId = null;
+        /** Pending signals waiting to be resolved */
+        this.pendingSignals = new Map();
+        /** Signal polling interval (ms) */
+        this.signalPollInterval = 2000;
+        /** Signal polling timer */
+        this.signalPollTimer = null;
+        /** Session log fields for logging */
+        this.sessionLogFields = {};
+        /** LogService instance for logging operations */
+        this.logService = null;
+        /** Base log fields inherited by all step logs */
+        this.baseLogs = null;
+        this.config = config;
+        this.workflow = workflow;
+        this.sessionLogFields = sessionLogFields || {};
+        // Initialize processor service for executing components
+        this.processorService = new processor_service_1.default({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+        });
+        // Initialize product builder
+        this.productBuilder = new products_service_1.default({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+        });
+        // Initialize processor API service for persisting results
+        this.processorApiService = new processorApi_service_1.ProcessorApiService(config.env_type);
+        // Initialize workflow API service for signal polling
+        this.workflowApiService = new workflowApi_service_1.WorkflowApiService(config.env_type);
+        // Initialize graph service for graph operations
+        this.graphService = new graph_1.GraphService({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+        });
+        // Initialize database service for database actions
+        this.databaseService = new database_1.DatabaseService({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+        });
+        // Initialize quota service for quota steps
+        this.quotaService = new resilience_1.QuotaService({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+        });
+        // Initialize fallback service for fallback steps
+        this.fallbackService = new resilience_1.FallbackService({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+        });
+        // Initialize workflow state
+        this.state = {
+            workflow_id: (0, crypto_1.randomUUID)(),
+            workflow_tag: workflow.tag,
+            product: options.product,
+            env: options.env,
+            input: options.input,
+            steps: {},
+            completed_steps: [],
+            state: {},
+            status: types_1.WorkflowStatus.PENDING,
+            started_at: Date.now(),
+        };
+    }
+    /**
+     * Get auth payload for API calls
+     */
+    getAuthPayload() {
+        return {
+            user_id: this.config.user_id,
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            token: this.config.token,
+        };
+    }
+    /**
+     * Persist workflow execution result to backend
+     */
+    async persistExecutionResult(status, output, error) {
+        try {
+            const resultData = {
+                workflow_tag: this.state.workflow_tag,
+                input: this.state.input,
+                output,
+                completed_steps: this.state.completed_steps,
+                failed_step: this.state.failed_step,
+                step_outputs: this.state.steps,
+                error,
+            };
+            const processorResult = {
+                process_id: this.state.workflow_id,
+                product_id: this.productId || '',
+                env: this.state.env,
+                component: types_1.LogEventTypes.WORKFLOW,
+                status,
+                start: this.state.started_at,
+                end: Date.now(),
+                retryable: true,
+                result: resultData,
+                feature_id: '',
+                input: { product: this.state.product, env: this.state.env, event: this.state.workflow_tag, input: this.state.input },
+            };
+            await this.processorApiService.saveResult(processorResult, this.getAuthPayload());
+        }
+        catch (err) {
+            // Log error but don't throw - persistence failure shouldn't fail the workflow
+            console.error('Failed to persist workflow execution result:', err);
+        }
+    }
+    /**
+     * Persist individual step execution to backend
+     */
+    async persistStepResult(step, status, output, error, duration) {
+        try {
+            const resultData = {
+                workflow_id: this.state.workflow_id,
+                workflow_tag: this.state.workflow_tag,
+                step_tag: step.tag,
+                step_type: step.type,
+                input: step.input,
+                output,
+                error,
+            };
+            const stepResult = {
+                process_id: `${this.state.workflow_id}:${step.tag}`,
+                product_id: this.productId || '',
+                env: this.state.env,
+                component: types_1.LogEventTypes.WORKFLOW_STEP,
+                status,
+                start: Date.now() - (duration || 0),
+                end: Date.now(),
+                retryable: true,
+                result: resultData,
+                feature_id: '',
+                input: step.input,
+            };
+            await this.processorApiService.saveResult(stepResult, this.getAuthPayload());
+        }
+        catch (err) {
+            // Log error but don't throw - persistence failure shouldn't fail the step
+            console.error(`Failed to persist step ${step.tag} result:`, err);
+        }
+    }
+    /**
+     * Initialize logging service and base log fields
+     */
+    initializeLogging() {
+        if (!this.logService && this.productId) {
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+            });
+            // Set up base logs that all step logs inherit
+            this.baseLogs = Object.assign({ product_tag: this.state.product, workspace_id: this.config.workspace_id, env: this.state.env, process_id: this.state.workflow_id, type: logs_types_1.LogEventTypes.WORKFLOW, parent_tag: this.state.workflow_tag }, this.sessionLogFields);
+        }
+    }
+    /**
+     * Log a step execution event
+     */
+    logStepEvent(step, message, status, additionalData) {
+        if (!this.logService || !this.baseLogs)
+            return;
+        this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { child_tag: step.tag, message,
+            status, data: Object.assign({ workflow: this.state.workflow_tag, step: step.tag, step_type: step.type }, additionalData) }));
+    }
+    /**
+     * Execute the workflow
+     */
+    async execute() {
+        var _a, _b, _c, _d, _e;
+        const startTime = Date.now();
+        try {
+            // Initialize product builder with the product
+            await this.productBuilder.initializeProductByTag(this.state.product);
+            this.productId = this.productBuilder.fetchProductId();
+            // Initialize logging after we have product ID
+            this.initializeLogging();
+            this.state.status = types_1.WorkflowStatus.RUNNING;
+            // Get steps in execution order (respecting dependencies)
+            const orderedSteps = this.getOrderedSteps();
+            // Execute each step
+            for (const step of orderedSteps) {
+                // Check step condition if present
+                if (step.condition && !this.evaluateCondition(step.condition)) {
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (condition not met)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue; // Skip step if condition not met
+                }
+                this.state.current_step = step.tag;
+                // Log step start
+                this.logStepEvent(step, `Step ${step.tag} - started`, logs_types_1.LogEventStatus.PROCESSING);
+                const result = await this.executeStep(step);
+                // Log step completion
+                this.logStepEvent(step, result.success ? `Step ${step.tag} - completed` : `Step ${step.tag} - failed`, result.success ? logs_types_1.LogEventStatus.SUCCESS : logs_types_1.LogEventStatus.FAIL, { duration: result.duration, error: result.error });
+                // Persist step result to backend
+                await this.persistStepResult(step, result.success ? types_1.LogEventStatus.SUCCESS : types_1.LogEventStatus.FAIL, result.output, result.error, result.duration);
+                if (!result.success) {
+                    this.state.failed_step = step.tag;
+                    // Check if step allows failure
+                    if ((_a = step.options) === null || _a === void 0 ? void 0 : _a.allow_fail) {
+                        // Store error but continue
+                        this.state.steps[step.tag] = { error: result.error };
+                        continue;
+                    }
+                    // Check if step is optional
+                    if ((_b = step.options) === null || _b === void 0 ? void 0 : _b.optional) {
+                        // Don't trigger rollback, just continue
+                        continue;
+                    }
+                    // Trigger rollback
+                    this.state.status = types_1.WorkflowStatus.ROLLING_BACK;
+                    const rollbackResult = await this.executeRollback(step.tag, result.error || 'Step failed');
+                    // Persist failed workflow result
+                    await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, result.error);
+                    // Publish logs
+                    await ((_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish());
+                    return {
+                        status: types_1.WorkflowStatus.ROLLED_BACK,
+                        workflow_id: this.state.workflow_id,
+                        error: result.error,
+                        execution_time: Date.now() - startTime,
+                        completed_steps: this.state.completed_steps,
+                        failed_step: step.tag,
+                        rollback_info: {
+                            triggered_by: step.tag,
+                            reason: result.error || 'Step failed',
+                            rolled_back_steps: rollbackResult.rolled_back_steps,
+                            failed_rollbacks: rollbackResult.failed_steps,
+                        },
+                    };
+                }
+                // Store step output and mark as completed
+                this.state.steps[step.tag] = result.output;
+                this.state.completed_steps.push(step.tag);
+            }
+            this.state.status = types_1.WorkflowStatus.COMPLETED;
+            this.state.ended_at = Date.now();
+            // Determine output - use last step output or aggregate
+            const output = this.determineWorkflowOutput();
+            // Persist successful workflow result
+            await this.persistExecutionResult(types_1.LogEventStatus.SUCCESS, output);
+            // Publish logs
+            await ((_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish());
+            return {
+                status: types_1.WorkflowStatus.COMPLETED,
+                workflow_id: this.state.workflow_id,
+                output: output,
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+            };
+        }
+        catch (error) {
+            this.state.status = types_1.WorkflowStatus.FAILED;
+            this.state.ended_at = Date.now();
+            // Persist failed workflow result
+            await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, error.message);
+            // Publish logs
+            await ((_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish());
+            return {
+                status: types_1.WorkflowStatus.FAILED,
+                workflow_id: this.state.workflow_id,
+                error: error.message || 'Workflow execution failed',
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+                failed_step: this.state.current_step,
+            };
+        }
+    }
+    /**
+     * Execute a single step
+     */
+    async executeStep(step) {
+        const startTime = Date.now();
+        try {
+            // Resolve input with data references
+            const resolvedInput = this.resolveInput(step.input || {});
+            let output;
+            switch (step.type) {
+                case types_1.WorkflowStepType.ACTION:
+                    output = await this.executeActionStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.DATABASE_ACTION:
+                    output = await this.executeDatabaseStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.NOTIFICATION:
+                    output = await this.executeNotificationStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.STORAGE:
+                    output = await this.executeStorageStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.PUBLISH:
+                    output = await this.executePublishStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.GRAPH:
+                    output = await this.executeGraphStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.QUOTA:
+                    output = await this.executeQuotaStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.FALLBACK:
+                    output = await this.executeFallbackStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.CHILD_WORKFLOW:
+                    output = await this.executeChildWorkflowStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.SLEEP:
+                    await this.executeSleepStep(step, resolvedInput);
+                    output = { slept: true };
+                    break;
+                case types_1.WorkflowStepType.WAIT_FOR_SIGNAL:
+                    output = await this.executeWaitForSignalStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.CHECKPOINT:
+                    await this.executeCheckpointStep(step, resolvedInput);
+                    output = { checkpoint: step.tag };
+                    break;
+                default:
+                    throw new Error(`Unknown step type: ${step.type}`);
+            }
+            return {
+                success: true,
+                output,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Step execution failed',
+                duration: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Execute an action step
+     */
+    async executeActionStep(step, input) {
+        var _a, _b;
+        return this.processorService.processAction({
+            product: this.state.product,
+            env: this.state.env,
+            app: step.app,
+            action: step.event,
+            input: input,
+            retries: ((_a = step.options) === null || _a === void 0 ? void 0 : _a.retries) || 0,
+            cache: (_b = step.options) === null || _b === void 0 ? void 0 : _b.cache,
+        });
+    }
+    /**
+     * Execute a database action step
+     */
+    async executeDatabaseStep(step, input) {
+        return this.databaseService.execute({
+            product: this.state.product,
+            env: this.state.env,
+            database: step.database,
+            action: step.event,
+            input: input,
+        });
+    }
+    /**
+     * Execute a notification step
+     */
+    async executeNotificationStep(step, input) {
+        var _a;
+        const event = `${step.notification}:${step.event}`;
+        return this.processorService.processNotification({
+            product: this.state.product,
+            env: this.state.env,
+            event,
+            input: input,
+            retries: ((_a = step.options) === null || _a === void 0 ? void 0 : _a.retries) || 0,
+        });
+    }
+    /**
+     * Execute a storage step
+     */
+    async executeStorageStep(step, input) {
+        var _a;
+        const event = `${step.storage}:${step.event}`;
+        return this.processorService.processStorage({
+            product: this.state.product,
+            env: this.state.env,
+            event,
+            input: input,
+            retries: ((_a = step.options) === null || _a === void 0 ? void 0 : _a.retries) || 0,
+        });
+    }
+    /**
+     * Execute a publish step
+     */
+    async executePublishStep(step, input) {
+        const event = `${step.broker}:${step.event}`;
+        return this.processorService.processMessageBrokerPublish({
+            product: this.state.product,
+            env: this.state.env,
+            event,
+            input: input,
+        });
+    }
+    /**
+     * Execute a graph step
+     * Supports: execute (custom action), createNode, updateNode, deleteNode,
+     * createRelationship, deleteRelationship, query
+     */
+    async executeGraphStep(step, input) {
+        const graphTag = step.graph;
+        const action = step.event;
+        // Connect to the graph database
+        await this.graphService.connect({
+            env: this.state.env,
+            product: this.state.product,
+            graph: graphTag,
+        });
+        try {
+            // Handle different graph operations based on action
+            switch (action) {
+                case 'createNode': {
+                    const result = await this.graphService.createNode({
+                        labels: input.labels,
+                        properties: input.properties,
+                    });
+                    return result;
+                }
+                case 'updateNode': {
+                    const result = await this.graphService.updateNode({
+                        id: input.id,
+                        properties: input.properties,
+                    });
+                    return result;
+                }
+                case 'deleteNode': {
+                    const result = await this.graphService.deleteNode({
+                        id: input.id,
+                        detach: input.detach,
+                    });
+                    return result;
+                }
+                case 'createRelationship': {
+                    const result = await this.graphService.createRelationship({
+                        startNodeId: input.startNodeId || input.from,
+                        endNodeId: input.endNodeId || input.to,
+                        type: input.type,
+                        properties: input.properties,
+                    });
+                    return result;
+                }
+                case 'deleteRelationship': {
+                    const result = await this.graphService.deleteRelationship({
+                        id: input.id,
+                    });
+                    return result;
+                }
+                case 'query': {
+                    const result = await this.graphService.query(input.query, input.params);
+                    return result;
+                }
+                case 'findNodes': {
+                    const result = await this.graphService.findNodes({
+                        labels: input.labels,
+                        where: input.where,
+                        limit: input.limit,
+                        skip: input.skip,
+                    });
+                    return result;
+                }
+                case 'traverse': {
+                    const result = await this.graphService.traverse({
+                        startNodeId: input.startNodeId,
+                        relationshipTypes: input.relationshipTypes,
+                        direction: input.direction,
+                        maxDepth: input.maxDepth,
+                    });
+                    return result;
+                }
+                default: {
+                    // Execute a custom graph action
+                    const result = await this.graphService.execute({
+                        product: this.state.product,
+                        env: this.state.env,
+                        graph: graphTag,
+                        action,
+                        input,
+                    });
+                    return result;
+                }
+            }
+        }
+        finally {
+            // Disconnect from the graph
+            await this.graphService.disconnect();
+        }
+    }
+    /**
+     * Execute a quota step
+     */
+    async executeQuotaStep(step, input) {
+        return this.quotaService.run({
+            product: this.state.product,
+            env: this.state.env,
+            tag: step.quota,
+            input,
+        });
+    }
+    /**
+     * Execute a fallback step
+     */
+    async executeFallbackStep(step, input) {
+        return this.fallbackService.run({
+            product: this.state.product,
+            env: this.state.env,
+            tag: step.fallback,
+            input,
+        });
+    }
+    /**
+     * Execute a child workflow step
+     */
+    async executeChildWorkflowStep(step, input) {
+        // Create a new executor for the child workflow
+        const childWorkflow = await this.productBuilder.fetchWorkflow(step.workflow);
+        if (!childWorkflow) {
+            throw new Error(`Child workflow ${step.workflow} not found`);
+        }
+        const childExecutor = new WorkflowExecutor(this.config, childWorkflow, {
+            product: this.state.product,
+            env: this.state.env,
+            tag: step.workflow,
+            input,
+        });
+        const result = await childExecutor.execute();
+        if (result.status !== types_1.WorkflowStatus.COMPLETED) {
+            throw new Error(`Child workflow failed: ${result.error}`);
+        }
+        return result.output;
+    }
+    /**
+     * Execute a sleep step
+     */
+    async executeSleepStep(step, input) {
+        var _a;
+        const duration = input.duration || ((_a = step.options) === null || _a === void 0 ? void 0 : _a.timeout) || 1000;
+        await this.sleep(duration);
+    }
+    /**
+     * Execute a wait for signal step
+     * Polls the backend API for signal delivery until received or timeout
+     */
+    async executeWaitForSignalStep(step, input) {
+        var _a;
+        const signalName = step.event;
+        const signals = input.signals || [signalName];
+        const timeout = ((_a = step.options) === null || _a === void 0 ? void 0 : _a.timeout) || 300000; // 5 min default
+        const startTime = Date.now();
+        // Store that we're waiting for these signals in state
+        this.state.state[`waiting_for_signal:${step.tag}`] = {
+            signals,
+            started_at: startTime,
+            timeout,
+        };
+        // Persist the waiting state to backend
+        await this.persistExecutionResult(types_1.LogEventStatus.WAITING);
+        return new Promise((resolve, reject) => {
+            // Create pending signal entry
+            const pendingSignal = {
+                signal: signalName,
+                resolve,
+                reject,
+            };
+            // Store for each signal we're waiting for
+            for (const sig of signals) {
+                this.pendingSignals.set(sig, pendingSignal);
+            }
+            // Set up timeout
+            if (timeout > 0) {
+                pendingSignal.timeout = setTimeout(() => {
+                    // Clean up pending signals
+                    for (const sig of signals) {
+                        this.pendingSignals.delete(sig);
+                    }
+                    this.stopSignalPolling();
+                    // Update state
+                    delete this.state.state[`waiting_for_signal:${step.tag}`];
+                    this.state.state[`signal_timeout:${step.tag}`] = {
+                        signals,
+                        timed_out_at: Date.now(),
+                    };
+                    reject(new Error(`Signal wait timed out after ${timeout}ms waiting for: ${signals.join(', ')}`));
+                }, timeout);
+            }
+            // Start polling for signals
+            this.startSignalPolling(signals, step.tag);
+        });
+    }
+    /**
+     * Start polling the backend for signal delivery
+     */
+    startSignalPolling(signals, stepTag) {
+        // Don't start multiple pollers
+        if (this.signalPollTimer)
+            return;
+        const poll = async () => {
+            var _a;
+            try {
+                // Get workflow status from backend to check for received signals
+                const status = await this.workflowApiService.getStatus(this.state.workflow_id, this.state.product, this.state.env, this.getAuthPayload());
+                if (status) {
+                    // Check if any of the signals we're waiting for have been received
+                    const receivedSignals = ((_a = status.state) === null || _a === void 0 ? void 0 : _a.received_signals) || {};
+                    for (const signalName of signals) {
+                        const signalKey = `signal:${signalName}`;
+                        if (receivedSignals[signalKey]) {
+                            const signalData = receivedSignals[signalKey];
+                            const pendingSignal = this.pendingSignals.get(signalName);
+                            if (pendingSignal) {
+                                // Clear timeout
+                                if (pendingSignal.timeout) {
+                                    clearTimeout(pendingSignal.timeout);
+                                }
+                                // Clean up
+                                for (const sig of signals) {
+                                    this.pendingSignals.delete(sig);
+                                }
+                                this.stopSignalPolling();
+                                // Update state
+                                delete this.state.state[`waiting_for_signal:${stepTag}`];
+                                this.state.state[`signal_received:${stepTag}`] = {
+                                    signal: signalName,
+                                    payload: signalData,
+                                    received_at: Date.now(),
+                                };
+                                // Resolve the promise
+                                pendingSignal.resolve({
+                                    signal: signalName,
+                                    payload: signalData,
+                                    received_at: Date.now(),
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                // Log but continue polling - transient errors shouldn't stop us
+                console.error('Signal polling error:', error);
+            }
+            // Schedule next poll if we still have pending signals
+            if (this.pendingSignals.size > 0) {
+                this.signalPollTimer = setTimeout(poll, this.signalPollInterval);
+            }
+        };
+        // Start polling
+        poll();
+    }
+    /**
+     * Stop the signal polling timer
+     */
+    stopSignalPolling() {
+        if (this.signalPollTimer) {
+            clearTimeout(this.signalPollTimer);
+            this.signalPollTimer = null;
+        }
+    }
+    /**
+     * Deliver a signal to this workflow (called by external signal handler)
+     */
+    deliverSignal(signalName, payload) {
+        const pendingSignal = this.pendingSignals.get(signalName);
+        if (!pendingSignal) {
+            return false;
+        }
+        // Clear timeout
+        if (pendingSignal.timeout) {
+            clearTimeout(pendingSignal.timeout);
+        }
+        // Clean up all related pending signals
+        // (in case we were waiting for multiple signals)
+        for (const [key, value] of this.pendingSignals.entries()) {
+            if (value === pendingSignal) {
+                this.pendingSignals.delete(key);
+            }
+        }
+        this.stopSignalPolling();
+        // Resolve with the signal data
+        pendingSignal.resolve({
+            signal: signalName,
+            payload,
+            received_at: Date.now(),
+        });
+        return true;
+    }
+    /**
+     * Execute a checkpoint step
+     */
+    async executeCheckpointStep(step, input) {
+        // Store checkpoint data in workflow state
+        this.state.state[`checkpoint:${step.tag}`] = {
+            timestamp: Date.now(),
+            completed_steps: [...this.state.completed_steps],
+            data: input,
+        };
+    }
+    /**
+     * Execute rollback for completed steps
+     */
+    async executeRollback(failedStep, reason) {
+        var _a;
+        const rolledBackSteps = [];
+        const failedRollbacks = [];
+        // Get rollback strategy
+        const strategy = ((_a = this.workflow.options) === null || _a === void 0 ? void 0 : _a.rollback_strategy) || types_1.WorkflowRollbackStrategy.REVERSE_ALL;
+        // Determine which steps to rollback
+        let stepsToRollback = [];
+        switch (strategy) {
+            case types_1.WorkflowRollbackStrategy.REVERSE_ALL:
+                // Rollback all completed steps in reverse order
+                stepsToRollback = this.state.completed_steps
+                    .slice()
+                    .reverse()
+                    .map((tag) => this.findStep(tag))
+                    .filter((step) => step !== undefined);
+                break;
+            case types_1.WorkflowRollbackStrategy.REVERSE_CRITICAL:
+                // Only rollback steps marked as critical
+                stepsToRollback = this.state.completed_steps
+                    .slice()
+                    .reverse()
+                    .map((tag) => this.findStep(tag))
+                    .filter((step) => { var _a; return step !== undefined && ((_a = step.options) === null || _a === void 0 ? void 0 : _a.critical) === true; });
+                break;
+            case types_1.WorkflowRollbackStrategy.NONE:
+                // No rollback
+                return { success: true, rolled_back_steps: [], reason };
+        }
+        // Execute rollback for each step
+        for (const step of stepsToRollback) {
+            if (!step.rollback) {
+                continue; // No rollback defined for this step
+            }
+            try {
+                const stepOutput = this.state.steps[step.tag];
+                await this.executeRollbackHandler(step.rollback, stepOutput);
+                rolledBackSteps.push(step.tag);
+            }
+            catch (error) {
+                if (!step.rollback.continue_on_failure) {
+                    failedRollbacks.push({ tag: step.tag, error: error.message });
+                    // Stop rollback if continue_on_failure is not set
+                    break;
+                }
+                failedRollbacks.push({ tag: step.tag, error: error.message });
+            }
+        }
+        return {
+            success: failedRollbacks.length === 0,
+            rolled_back_steps: rolledBackSteps,
+            failed_steps: failedRollbacks.length > 0 ? failedRollbacks : undefined,
+            reason,
+        };
+    }
+    /**
+     * Execute a rollback handler
+     */
+    async executeRollbackHandler(rollback, stepOutput) {
+        var _a, _b, _c;
+        if (!rollback)
+            return;
+        // Resolve rollback input, including step output references
+        const resolvedInput = this.resolveInput(rollback.input || {}, stepOutput);
+        switch (rollback.type) {
+            case types_1.WorkflowStepType.ACTION:
+                await this.processorService.processAction({
+                    product: this.state.product,
+                    env: this.state.env,
+                    app: rollback.app,
+                    action: rollback.event,
+                    input: resolvedInput,
+                    retries: (_a = rollback.retries) !== null && _a !== void 0 ? _a : 0,
+                });
+                break;
+            case types_1.WorkflowStepType.DATABASE_ACTION:
+                await this.databaseService.execute({
+                    product: this.state.product,
+                    env: this.state.env,
+                    database: rollback.database,
+                    action: rollback.event,
+                    input: resolvedInput,
+                });
+                break;
+            case types_1.WorkflowStepType.NOTIFICATION:
+                const notifEvent = `${rollback.notification}:${rollback.event}`;
+                await this.processorService.processNotification({
+                    product: this.state.product,
+                    env: this.state.env,
+                    event: notifEvent,
+                    input: resolvedInput,
+                    retries: (_b = rollback.retries) !== null && _b !== void 0 ? _b : 0,
+                });
+                break;
+            case types_1.WorkflowStepType.STORAGE:
+                const storageEvent = `${rollback.storage}:${rollback.event}`;
+                await this.processorService.processStorage({
+                    product: this.state.product,
+                    env: this.state.env,
+                    event: storageEvent,
+                    input: resolvedInput,
+                    retries: (_c = rollback.retries) !== null && _c !== void 0 ? _c : 0,
+                });
+                break;
+            case types_1.WorkflowStepType.PUBLISH:
+                const pubEvent = `${rollback.broker}:${rollback.event}`;
+                await this.processorService.processMessageBrokerPublish({
+                    product: this.state.product,
+                    env: this.state.env,
+                    event: pubEvent,
+                    input: resolvedInput,
+                });
+                break;
+        }
+    }
+    /**
+     * Resolve input by replacing data references
+     */
+    resolveInput(input, stepOutput) {
+        const resolved = {};
+        for (const [key, value] of Object.entries(input)) {
+            resolved[key] = this.resolveValue(value, stepOutput);
+        }
+        return resolved;
+    }
+    /**
+     * Resolve a single value, handling data references
+     */
+    resolveValue(value, stepOutput) {
+        if (typeof value === 'string') {
+            return this.resolveStringValue(value, stepOutput);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.resolveValue(item, stepOutput));
+        }
+        if (value && typeof value === 'object') {
+            return this.resolveInput(value, stepOutput);
+        }
+        return value;
+    }
+    /**
+     * Resolve string value with data reference syntax
+     * Supports: $Input{field}, $Step{tag}{field}, $State{key}, $StepOutput{field}
+     */
+    resolveStringValue(value, stepOutput) {
+        // Check for $Input{field}
+        const inputMatch = value.match(/^\$Input\{(.+)\}$/);
+        if (inputMatch) {
+            return this.getNestedValue(this.state.input, inputMatch[1]);
+        }
+        // Check for $Step{tag}{field}
+        const stepMatch = value.match(/^\$Step\{(.+)\}\{(.+)\}$/);
+        if (stepMatch) {
+            const [, stepTag, field] = stepMatch;
+            const stepData = this.state.steps[stepTag];
+            if (stepData) {
+                return this.getNestedValue(stepData, field);
+            }
+            return undefined;
+        }
+        // Check for $State{key}
+        const stateMatch = value.match(/^\$State\{(.+)\}$/);
+        if (stateMatch) {
+            return this.state.state[stateMatch[1]];
+        }
+        // Check for $StepOutput{field} - reference to the step output being used in rollback
+        const outputMatch = value.match(/^\$StepOutput\{(.+)\}$/);
+        if (outputMatch && stepOutput) {
+            return this.getNestedValue(stepOutput, outputMatch[1]);
+        }
+        // Check for inline references like "text with $Input{field} in it"
+        return value.replace(/\$Input\{([^}]+)\}/g, (_, field) => {
+            const val = this.getNestedValue(this.state.input, field);
+            return String(val !== null && val !== void 0 ? val : '');
+        }).replace(/\$Step\{([^}]+)\}\{([^}]+)\}/g, (_, stepTag, field) => {
+            const stepData = this.state.steps[stepTag];
+            if (stepData) {
+                const val = this.getNestedValue(stepData, field);
+                return String(val !== null && val !== void 0 ? val : '');
+            }
+            return '';
+        });
+    }
+    /**
+     * Get nested value from object using dot notation
+     */
+    getNestedValue(obj, path) {
+        const keys = path.split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[key];
+        }
+        return current;
+    }
+    /**
+     * Get ordered steps respecting dependencies
+     */
+    getOrderedSteps() {
+        const steps = this.workflow.steps;
+        const ordered = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (step) => {
+            if (visited.has(step.tag))
+                return;
+            if (visiting.has(step.tag)) {
+                throw new Error(`Circular dependency detected at step ${step.tag}`);
+            }
+            visiting.add(step.tag);
+            // Visit dependencies first
+            if (step.depends_on) {
+                for (const depTag of step.depends_on) {
+                    const depStep = steps.find((s) => s.tag === depTag);
+                    if (depStep) {
+                        visit(depStep);
+                    }
+                }
+            }
+            visiting.delete(step.tag);
+            visited.add(step.tag);
+            ordered.push(step);
+        };
+        for (const step of steps) {
+            visit(step);
+        }
+        return ordered;
+    }
+    /**
+     * Find a step by tag
+     */
+    findStep(tag) {
+        return this.workflow.steps.find((s) => s.tag === tag);
+    }
+    /**
+     * Evaluate a condition string
+     */
+    evaluateCondition(condition) {
+        // Simple condition evaluation
+        // Supports: $Step{tag}{field} == value, $Input{field} != value
+        try {
+            // Replace references with actual values
+            const resolved = this.resolveStringValue(condition);
+            // Handle comparison operators
+            if (typeof resolved === 'string') {
+                const eqMatch = resolved.match(/(.+)\s*==\s*(.+)/);
+                if (eqMatch) {
+                    const left = eqMatch[1].trim();
+                    const right = eqMatch[2].trim().replace(/^["']|["']$/g, '');
+                    return String(left) === String(right);
+                }
+                const neqMatch = resolved.match(/(.+)\s*!=\s*(.+)/);
+                if (neqMatch) {
+                    const left = neqMatch[1].trim();
+                    const right = neqMatch[2].trim().replace(/^["']|["']$/g, '');
+                    return String(left) !== String(right);
+                }
+            }
+            // Truthy check
+            return Boolean(resolved);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Determine workflow output
+     */
+    determineWorkflowOutput() {
+        // If workflow has explicit output mapping, use it
+        if (this.workflow.output) {
+            return this.resolveInput(this.workflow.output);
+        }
+        // Otherwise, return last step output
+        const lastStep = this.state.completed_steps[this.state.completed_steps.length - 1];
+        return lastStep ? this.state.steps[lastStep] : {};
+    }
+    /**
+     * Sleep for specified duration
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Resume a workflow from a previous state
+     *
+     * @param options - Resume options including completed steps, state, and starting point
+     */
+    async resume(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const startTime = Date.now();
+        try {
+            // Initialize product builder with the product
+            await this.productBuilder.initializeProductByTag(this.state.product);
+            this.productId = this.productBuilder.fetchProductId();
+            // Initialize logging after we have product ID
+            this.initializeLogging();
+            // Restore previous state
+            this.state.completed_steps = options.completed_steps || [];
+            this.state.state = options.state || {};
+            // Restore step outputs if provided
+            if (options.step_outputs) {
+                this.state.steps = Object.assign(Object.assign({}, this.state.steps), options.step_outputs);
+            }
+            this.state.status = types_1.WorkflowStatus.RUNNING;
+            // Get steps in execution order
+            const orderedSteps = this.getOrderedSteps();
+            // Find starting point
+            let startIndex = 0;
+            if (options.from_checkpoint) {
+                // Find the step after the checkpoint
+                const checkpointIndex = orderedSteps.findIndex((s) => s.type === types_1.WorkflowStepType.CHECKPOINT && s.tag === options.from_checkpoint);
+                if (checkpointIndex >= 0) {
+                    startIndex = checkpointIndex + 1;
+                }
+            }
+            else if (options.from_step) {
+                // Start from the specified step
+                startIndex = orderedSteps.findIndex((s) => s.tag === options.from_step);
+                if (startIndex === -1) {
+                    throw new Error(`Step ${options.from_step} not found`);
+                }
+            }
+            else {
+                // Start after last completed step
+                const lastCompleted = this.state.completed_steps[this.state.completed_steps.length - 1];
+                if (lastCompleted) {
+                    const lastIndex = orderedSteps.findIndex((s) => s.tag === lastCompleted);
+                    startIndex = lastIndex + 1;
+                }
+            }
+            // Execute remaining steps
+            for (let i = startIndex; i < orderedSteps.length; i++) {
+                const step = orderedSteps[i];
+                // Skip if already completed or in skip list
+                if (this.state.completed_steps.includes(step.tag)) {
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (already completed)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue;
+                }
+                if ((_a = options.skip_steps) === null || _a === void 0 ? void 0 : _a.includes(step.tag)) {
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (in skip list)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue;
+                }
+                // Check step condition if present
+                if (step.condition && !this.evaluateCondition(step.condition)) {
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (condition not met)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue;
+                }
+                this.state.current_step = step.tag;
+                // Log step start
+                this.logStepEvent(step, `Step ${step.tag} - started`, logs_types_1.LogEventStatus.PROCESSING);
+                const result = await this.executeStep(step);
+                // Log step completion
+                this.logStepEvent(step, result.success ? `Step ${step.tag} - completed` : `Step ${step.tag} - failed`, result.success ? logs_types_1.LogEventStatus.SUCCESS : logs_types_1.LogEventStatus.FAIL, { duration: result.duration, error: result.error });
+                // Persist step result to backend
+                await this.persistStepResult(step, result.success ? types_1.LogEventStatus.SUCCESS : types_1.LogEventStatus.FAIL, result.output, result.error, result.duration);
+                if (!result.success) {
+                    this.state.failed_step = step.tag;
+                    // Check if step allows failure
+                    if ((_b = step.options) === null || _b === void 0 ? void 0 : _b.allow_fail) {
+                        this.state.steps[step.tag] = { error: result.error };
+                        continue;
+                    }
+                    // Check if step is optional
+                    if ((_c = step.options) === null || _c === void 0 ? void 0 : _c.optional) {
+                        continue;
+                    }
+                    // Trigger rollback
+                    this.state.status = types_1.WorkflowStatus.ROLLING_BACK;
+                    const rollbackResult = await this.executeRollback(step.tag, result.error || 'Step failed');
+                    await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, result.error);
+                    // Publish logs
+                    await ((_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish());
+                    return {
+                        status: types_1.WorkflowStatus.ROLLED_BACK,
+                        workflow_id: this.state.workflow_id,
+                        error: result.error,
+                        execution_time: Date.now() - startTime,
+                        completed_steps: this.state.completed_steps,
+                        failed_step: step.tag,
+                        rollback_info: {
+                            triggered_by: step.tag,
+                            reason: result.error || 'Step failed',
+                            rolled_back_steps: rollbackResult.rolled_back_steps,
+                            failed_rollbacks: rollbackResult.failed_steps,
+                        },
+                    };
+                }
+                // Store step output and mark as completed
+                this.state.steps[step.tag] = result.output;
+                this.state.completed_steps.push(step.tag);
+            }
+            this.state.status = types_1.WorkflowStatus.COMPLETED;
+            this.state.ended_at = Date.now();
+            const output = this.determineWorkflowOutput();
+            await this.persistExecutionResult(types_1.LogEventStatus.SUCCESS, output);
+            // Publish logs
+            await ((_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish());
+            return {
+                status: types_1.WorkflowStatus.COMPLETED,
+                workflow_id: this.state.workflow_id,
+                output: output,
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+            };
+        }
+        catch (error) {
+            this.state.status = types_1.WorkflowStatus.FAILED;
+            this.state.ended_at = Date.now();
+            await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, error.message);
+            // Publish logs
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            return {
+                status: types_1.WorkflowStatus.FAILED,
+                workflow_id: this.state.workflow_id,
+                error: error.message || 'Workflow resume failed',
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+                failed_step: this.state.current_step,
+            };
+        }
+    }
+}
+exports.WorkflowExecutor = WorkflowExecutor;
+exports.default = WorkflowExecutor;
+//# sourceMappingURL=workflow-executor.js.map