@ductape/sdk 0.0.4-v9 → 0.0.4-v91

package/dist/workflows/workflows.service.js

@@ -0,0 +1,1724 @@
+"use strict";
+/**
+ * Workflow Service
+ *
+ * Main service class for workflow operations.
+ * Provides CRUD operations and execution for Ductape Workflows.
+ *
+ * Based on Ductape Workflows Code-First API documentation.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowService = exports.WorkflowService = exports.WorkflowError = void 0;
+const crypto_1 = require("crypto");
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
+const workflowApi_service_1 = require("../api/services/workflowApi.service");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const processor_utils_1 = require("../processor/utils/processor.utils");
+const cache_manager_1 = require("../cache/cache.manager");
+const productsBuilder_types_1 = require("../types/productsBuilder.types");
+const workflow_executor_1 = require("./workflow-executor");
+/**
+ * Error class for workflow-related errors
+ */
+class WorkflowError extends Error {
+    constructor(message, code, details) {
+        if (typeof window !== 'undefined') {
+            throw new Error('Ductape SDK can only be initialized in a server environment.');
+        }
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'WorkflowError';
+    }
+    static configurationError(message) {
+        return new WorkflowError(message, 'CONFIGURATION_ERROR');
+    }
+    static validationError(message, details) {
+        return new WorkflowError(message, 'VALIDATION_ERROR', details);
+    }
+    static notFoundError(message) {
+        return new WorkflowError(message, 'NOT_FOUND');
+    }
+    static executionError(message, details) {
+        return new WorkflowError(message, 'EXECUTION_ERROR', details);
+    }
+}
+exports.WorkflowError = WorkflowError;
+/**
+ * Main Workflow Service class
+ * Provides unified interface for workflow management and execution
+ */
+class WorkflowService {
+    /**
+     * Create a new WorkflowService instance
+     * @param config - Optional configuration for authentication and workspace context
+     */
+    constructor(config) {
+        /** Service configuration */
+        this.config = null;
+        /** ProductBuilder instances cache (keyed by product tag) */
+        this.productBuilders = new Map();
+        /** Local workflow configurations */
+        this.localConfigs = new Map();
+        /** Workflow API service for backend communication */
+        this.workflowApiService = null;
+        /** LogService instance for logging operations */
+        this.logService = null;
+        /** Current product ID for logging */
+        this.productId = '';
+        /** Cache manager for 3-tier caching */
+        this.cacheManager = null;
+        this.config = config || null;
+        this._privateKey = (config === null || config === void 0 ? void 0 : config.private_key) || '';
+        if (config) {
+            this.workflowApiService = new workflowApi_service_1.WorkflowApiService(config.env_type);
+            // Initialize CacheManager if Redis client is provided
+            if (config.redis_client) {
+                this.cacheManager = new cache_manager_1.CacheManager({
+                    workspace_id: config.workspace_id,
+                    public_key: config.public_key,
+                    user_id: config.user_id,
+                    token: config.token,
+                    env_type: config.env_type,
+                    redis_client: config.redis_client,
+                });
+            }
+        }
+    }
+    // ==================== CONFIGURATION ====================
+    /**
+     * Update service configuration
+     */
+    updateConfig(config) {
+        this.config = config;
+        this.workflowApiService = new workflowApi_service_1.WorkflowApiService(config.env_type);
+    }
+    /**
+     * Get auth payload for API calls
+     */
+    getAuthPayload() {
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        return {
+            user_id: this.config.user_id,
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            token: this.config.token,
+        };
+    }
+    /**
+     * Ensure WorkflowApiService is initialized
+     */
+    ensureApiService() {
+        if (!this.workflowApiService) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        return this.workflowApiService;
+    }
+    /**
+     * Get service configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    // ==================== PRODUCT BUILDER MANAGEMENT ====================
+    /**
+     * Create a new ProductBuilder instance
+     */
+    createNewProductBuilder() {
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        return new products_service_1.default({
+            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,
+        });
+    }
+    /**
+     * Get or create a ProductBuilder instance for the given product tag
+     */
+    async getProductBuilder(productTag) {
+        let builder = this.productBuilders.get(productTag);
+        if (!builder) {
+            builder = this.createNewProductBuilder();
+            await builder.initializeProductByTag(productTag);
+            this.productBuilders.set(productTag, builder);
+            // Update productId for logging
+            this.productId = builder.fetchProductId() || '';
+        }
+        return builder;
+    }
+    /**
+     * Initialize logging service
+     */
+    initializeLogService() {
+        if (!this.logService && this.config) {
+            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,
+            });
+        }
+    }
+    /**
+     * Validate cache tag exists in product and return cache configuration
+     */
+    async validateCache(productTag, cacheTag) {
+        const builder = await this.getProductBuilder(productTag);
+        const cache = await builder.fetchCache(cacheTag);
+        if (!cache) {
+            throw WorkflowError.validationError(`Cache configuration '${cacheTag}' does not exist`);
+        }
+        return { expiry: cache.expiry };
+    }
+    /**
+     * Create a new ProcessorService instance for job scheduling
+     */
+    createNewProcessor() {
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        return new processor_service_1.default({
+            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,
+            private_key: this._privateKey,
+        });
+    }
+    // ==================== WORKFLOW CRUD OPERATIONS ====================
+    /**
+     * Create a new workflow from JSON schema
+     *
+     * @example
+     * ```ts
+     * await ductape.workflows.create('my-product', {
+     *   tag: 'order-fulfillment',
+     *   name: 'Order Fulfillment',
+     *   steps: [
+     *     { tag: 'validate', type: 'action', app: 'orders', event: 'validate', input: {} },
+     *     { tag: 'process', type: 'database_action', database: 'orders-db', event: 'create', input: {} },
+     *   ],
+     *   envs: [{ slug: 'prd' }],
+     * });
+     * ```
+     */
+    async create(productTag, workflowData) {
+        var _a;
+        // Validate required fields
+        if (!workflowData.name || !workflowData.tag || !((_a = workflowData.steps) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw WorkflowError.validationError('Workflow requires name, tag, and at least one step');
+        }
+        // Persist to backend using ProductBuilder
+        const builder = await this.getProductBuilder(productTag);
+        await builder.createWorkflow(workflowData);
+        // Store locally
+        const localConfig = {
+            name: workflowData.name,
+            tag: workflowData.tag,
+            description: workflowData.description,
+            input: workflowData.input,
+            output: workflowData.output,
+            steps: workflowData.steps,
+            signals: workflowData.signals,
+            queries: workflowData.queries,
+            options: workflowData.options,
+            envs: workflowData.envs,
+        };
+        this.localConfigs.set(workflowData.tag, localConfig);
+    }
+    /**
+     * Fetch all workflows for a product
+     *
+     * @example
+     * ```ts
+     * const workflows = await ductape.workflows.fetchAll('my-product');
+     * workflows.forEach(wf => console.log(wf.name, wf.tag));
+     * ```
+     */
+    async fetchAll(productTag) {
+        // Return local configs if no product tag
+        if (!productTag) {
+            return Array.from(this.localConfigs.values());
+        }
+        // Fetch from API using ProductBuilder
+        try {
+            const builder = await this.getProductBuilder(productTag);
+            const workflows = await builder.fetchWorkflows();
+            // Convert IProductWorkflow[] to IWorkflowConfig[]
+            return workflows.map((wf) => this.productWorkflowToConfig(wf));
+        }
+        catch (error) {
+            // Fall back to local configs if API fails
+            return Array.from(this.localConfigs.values());
+        }
+    }
+    /**
+     * Fetch a specific workflow by tag
+     *
+     * @example
+     * ```ts
+     * const workflow = await ductape.workflows.fetch('order-fulfillment', 'my-product');
+     * console.log(workflow?.name, workflow?.steps.length);
+     * ```
+     */
+    async fetch(workflowTag, productTag) {
+        // If productTag is provided, fetch from API
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                const workflow = await builder.fetchWorkflow(workflowTag);
+                if (workflow) {
+                    const config = this.productWorkflowToConfig(workflow);
+                    // Update local cache
+                    this.localConfigs.set(workflowTag, config);
+                    return config;
+                }
+                return null;
+            }
+            catch (error) {
+                // Fall back to local config
+                return this.localConfigs.get(workflowTag) || null;
+            }
+        }
+        return this.localConfigs.get(workflowTag) || null;
+    }
+    /**
+     * Update a workflow
+     *
+     * @example
+     * ```ts
+     * await ductape.workflows.update('order-fulfillment', 'my-product', {
+     *   description: 'Updated description',
+     *   options: { timeout: 3600000 },
+     * });
+     * ```
+     */
+    async update(workflowTag, productTag, updates) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // Update in backend
+        const builder = await this.getProductBuilder(productTag);
+        await builder.updateWorkflow(workflowTag, updates);
+        // Update local cache
+        const existing = this.localConfigs.get(workflowTag);
+        if (existing) {
+            const updated = Object.assign(Object.assign({}, existing), { name: updates.name || existing.name, description: (_a = updates.description) !== null && _a !== void 0 ? _a : existing.description, input: (_b = updates.input) !== null && _b !== void 0 ? _b : existing.input, output: (_c = updates.output) !== null && _c !== void 0 ? _c : existing.output, steps: updates.steps || existing.steps, signals: (_d = updates.signals) !== null && _d !== void 0 ? _d : existing.signals, queries: (_e = updates.queries) !== null && _e !== void 0 ? _e : existing.queries, options: (_f = updates.options) !== null && _f !== void 0 ? _f : existing.options, envs: (_g = updates.envs) !== null && _g !== void 0 ? _g : existing.envs });
+            this.localConfigs.set(workflowTag, updated);
+        }
+    }
+    /**
+     * Delete a workflow
+     *
+     * @example
+     * ```ts
+     * await ductape.workflows.delete('order-fulfillment', 'my-product');
+     * ```
+     */
+    async delete(workflowTag, productTag) {
+        // Delete from backend
+        const builder = await this.getProductBuilder(productTag);
+        await builder.deleteWorkflow(workflowTag);
+        // Remove from local cache
+        this.localConfigs.delete(workflowTag);
+    }
+    // ==================== CODE-FIRST API ====================
+    /**
+     * Define a workflow using the code-first API
+     * Compiles the handler to JSON schema and creates the workflow in one step
+     *
+     * @example
+     * ```ts
+     * const orderWorkflow = await ductape.workflows.define({
+     *   product: 'my-product',
+     *   tag: 'order-fulfillment',
+     *   name: 'Order Fulfillment',
+     *   handler: async (ctx) => {
+     *     const validation = await ctx.step('validate', async () => {
+     *       return ctx.action.run({
+     *         app: 'inventory-service',
+     *         event: 'validate-order',
+     *         input: { body: ctx.input },
+     *       });
+     *     });
+     *
+     *     if (!validation.valid) {
+     *       return { success: false, error: validation.reason };
+     *     }
+     *
+     *     return { success: true };
+     *   },
+     * });
+     * ```
+     */
+    async define(options) {
+        // Validate required fields
+        if (!options.tag || !options.name || !options.handler) {
+            throw WorkflowError.validationError('Workflow definition requires tag, name, and handler');
+        }
+        // Create a workflow compiler instance
+        const compiler = new WorkflowCompiler(options);
+        // Compile the handler to JSON schema
+        const schema = compiler.compile();
+        // If product is specified, create the workflow
+        if (options.product) {
+            await this.create(options.product, schema);
+        }
+        // Store locally
+        const localConfig = {
+            name: schema.name,
+            tag: schema.tag,
+            description: schema.description,
+            input: schema.input,
+            output: schema.output,
+            steps: schema.steps,
+            signals: schema.signals,
+            queries: schema.queries,
+            options: schema.options,
+            envs: schema.envs,
+        };
+        this.localConfigs.set(schema.tag, localConfig);
+        // Return the defined workflow with compile method
+        return {
+            tag: options.tag,
+            name: options.name,
+            handler: options.handler,
+            compile: () => schema,
+            schema,
+        };
+    }
+    // ==================== WORKFLOW EXECUTION ====================
+    /**
+     * Execute a workflow
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.workflows.execute({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   tag: 'order-fulfillment',
+     *   input: {
+     *     order_id: 'ORD-12345',
+     *     items: [{ product_id: 'PROD-1', quantity: 2 }],
+     *   },
+     * });
+     *
+     * console.log(result.status); // 'completed' | 'failed' | 'rolled_back'
+     * console.log(result.output);
+     * ```
+     */
+    async execute(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Fetch the workflow configuration from backend
+        const builder = await this.getProductBuilder(options.product);
+        const workflow = await builder.fetchWorkflow(options.tag);
+        if (!workflow) {
+            throw WorkflowError.notFoundError(`Workflow ${options.tag} not found`);
+        }
+        // Process session if provided - verify and resolve $Session{} references
+        if (options.session) {
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                if (sessionResult.error) {
+                    throw WorkflowError.executionError(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        // Initialize logging
+        this.initializeLogService();
+        const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: logs_types_1.LogEventTypes.WORKFLOW, parent_tag: options.tag, data: { workflow: options.tag, operation: 'execute' } }, sessionLogFields);
+        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        const { cache } = options;
+        try {
+            // Check cache for idempotency (prevent duplicate executions with same input)
+            if (cache && this.cacheManager && this._privateKey) {
+                const cacheConfig = await this.validateCache(options.product, cache);
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: options.product,
+                    component_tag: options.tag,
+                    component_type: 'workflow',
+                    operation: 'execute',
+                    input: { tag: options.tag, input: resolvedOptions.input },
+                    privateKey: this._privateKey,
+                    expiry: cacheConfig.expiry,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: `Workflow execute - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { workflow: options.tag, operation: 'execute', cache_source: cached.source } }));
+                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
+                    return cached.data;
+                }
+            }
+            // Create and run the workflow executor with resolved options and session context
+            const executor = new workflow_executor_1.WorkflowExecutor(this.config, workflow, resolvedOptions, this._privateKey, sessionLogFields);
+            const result = await executor.execute();
+            // Store in cache for idempotency
+            if (cache && this.cacheManager && this._privateKey) {
+                const cacheConfig = await this.validateCache(options.product, cache);
+                await this.cacheManager.store({
+                    cache_tag: cache,
+                    product_tag: options.product,
+                    component_tag: options.tag,
+                    component_type: 'workflow',
+                    operation: 'execute',
+                    input: { tag: options.tag, input: resolvedOptions.input },
+                    privateKey: this._privateKey,
+                    expiry: cacheConfig.expiry,
+                }, result);
+            }
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
+            return result;
+        }
+        catch (error) {
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - failed', failed_execution: true, data: { workflow: options.tag, operation: 'execute', error: error.message || String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish());
+            throw error;
+        }
+    }
+    // ==================== WORKFLOW DISPATCH ====================
+    /**
+     * Dispatch a workflow to run as a scheduled job
+     *
+     * @example
+     * ```ts
+     * // Schedule a workflow to run in 1 hour
+     * const result = await ductape.workflows.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow: 'order-fulfillment',
+     *   input: { order_id: 'ORD-123' },
+     *   schedule: { start_at: Date.now() + 3600000 },
+     * });
+     *
+     * // Run on a cron schedule
+     * const result = await ductape.workflows.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow: 'daily-report',
+     *   input: {},
+     *   schedule: { cron: '0 0 * * *' }, // Daily at midnight
+     * });
+     * ```
+     */
+    async dispatch(data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const processorService = this.createNewProcessor();
+        const productBuilder = await this.getProductBuilder(data.product);
+        const schedule = data.schedule || {};
+        const startAt = typeof schedule.start_at === 'string' ? new Date(schedule.start_at).getTime() : schedule.start_at || Date.now();
+        // Generate job tag based on workflow
+        const jobTag = `workflow:${data.workflow}`;
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedData = data;
+        // Process session if provided - verify and resolve $Session{} references
+        if (data.session) {
+            const privateKey = productBuilder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(data.session, privateKey, data, data.env);
+                if (sessionResult.error) {
+                    throw WorkflowError.executionError(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedData = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        // Initialize logging
+        this.initializeLogService();
+        const baseLogs = Object.assign({ product_tag: data.product, workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: data.env, process_id, type: logs_types_1.LogEventTypes.WORKFLOW, parent_tag: data.workflow, data: { workflow: data.workflow, operation: 'dispatch' } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow dispatch - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        const { cache } = data;
+        try {
+            // Check cache for idempotency (prevent duplicate dispatches with same input)
+            if (cache && this.cacheManager && this._privateKey) {
+                const cacheConfig = await this.validateCache(data.product, cache);
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: data.product,
+                    component_tag: data.workflow,
+                    component_type: 'workflow',
+                    operation: 'dispatch',
+                    input: { workflow: data.workflow, input: data.input, schedule: data.schedule },
+                    privateKey: this._privateKey,
+                    expiry: cacheConfig.expiry,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: `Workflow dispatch - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { workflow: data.workflow, operation: 'dispatch', cache_source: cached.source } }));
+                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+                    return cached.data;
+                }
+            }
+            // Check if job exists, if not create it
+            const existingJob = await productBuilder.fetchJob(jobTag);
+            if (!existingJob) {
+                await productBuilder.createJob({
+                    tag: jobTag,
+                    name: `Workflow: ${data.workflow}`,
+                    description: `Auto-created job for workflow ${data.workflow}`,
+                    type: productsBuilder_types_1.JobEventTypes.WORKFLOW, // Use workflow job type
+                    app: data.workflow,
+                    event: 'execute',
+                    executions: 0,
+                    intervals: schedule.every || 0,
+                    start_at: startAt,
+                });
+            }
+            const jobInput = {
+                product: data.product,
+                env: data.env,
+                event: jobTag,
+                input: resolvedData.input,
+                retries: data.retries || 0,
+                start_at: startAt,
+                session: data.session,
+                cache: data.cache,
+                repeat: schedule.cron || schedule.every
+                    ? {
+                        cron: schedule.cron,
+                        every: schedule.every,
+                        limit: schedule.limit,
+                        endDate: schedule.endDate,
+                        tz: schedule.tz,
+                    }
+                    : undefined,
+            };
+            await processorService.processJob(jobInput);
+            const isRecurring = !!(schedule.cron || schedule.every);
+            let nextRunAt;
+            if (isRecurring && schedule.every) {
+                nextRunAt = startAt + schedule.every;
+            }
+            const job_id = (0, crypto_1.randomUUID)();
+            const result = {
+                job_id,
+                status: startAt > Date.now() ? 'scheduled' : 'queued',
+                scheduled_at: startAt,
+                recurring: isRecurring,
+                next_run_at: nextRunAt,
+            };
+            // Store in cache for idempotency
+            if (cache && this.cacheManager && this._privateKey) {
+                const cacheConfig = await this.validateCache(data.product, cache);
+                await this.cacheManager.store({
+                    cache_tag: cache,
+                    product_tag: data.product,
+                    component_tag: data.workflow,
+                    component_type: 'workflow',
+                    operation: 'dispatch',
+                    input: { workflow: data.workflow, input: data.input, schedule: data.schedule },
+                    privateKey: this._privateKey,
+                    expiry: cacheConfig.expiry,
+                }, result);
+            }
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow dispatch - success', successful_execution: true, data: { workflow: data.workflow, operation: 'dispatch', job_id }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
+            return result;
+        }
+        catch (error) {
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow dispatch - failed', failed_execution: true, data: { workflow: data.workflow, operation: 'dispatch', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_h = this.logService) === null || _h === void 0 ? void 0 : _h.publish());
+            throw error;
+        }
+    }
+    // ==================== SIGNAL & QUERY ====================
+    /**
+     * Send a signal to a running workflow
+     *
+     * @example
+     * ```ts
+     * await ductape.workflows.signal({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   signal: 'approve',
+     *   payload: { approver_id: 'user-456', comments: 'Approved' },
+     * });
+     * ```
+     */
+    async signal(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        // Initialize logging
+        if (options.product) {
+            await this.getProductBuilder(options.product);
+        }
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: options.product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env: options.env,
+            process_id,
+            type: logs_types_1.LogEventTypes.WORKFLOW,
+            parent_tag: options.workflow_id,
+            child_tag: options.signal,
+            data: { workflow_id: options.workflow_id, signal: options.signal, operation: 'signal' },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow signal - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const apiService = this.ensureApiService();
+            const auth = this.getAuthPayload();
+            await apiService.sendSignal(options.workflow_id, {
+                product: options.product,
+                env: options.env,
+                signal: options.signal,
+                payload: options.payload,
+            }, auth);
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow signal - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow signal - failed', failed_execution: true, data: { workflow_id: options.workflow_id, signal: options.signal, operation: 'signal', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    /**
+     * Query a running workflow
+     *
+     * @example
+     * ```ts
+     * const status = await ductape.workflows.query({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   query: 'getStatus',
+     * });
+     *
+     * console.log(status.current_step, status.progress);
+     * ```
+     */
+    async query(options) {
+        // Query is handled by getting workflow status and extracting query result
+        const status = await this.status({
+            product: options.product,
+            env: options.env,
+            workflow_id: options.workflow_id,
+        });
+        if (!status) {
+            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
+        }
+        // Return the state which contains query results
+        return (status.state[options.query] || status);
+    }
+    // ==================== REPLAY, RESTART & RESUME ====================
+    /**
+     * Replay a workflow with the same input
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.workflows.replay({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   reason: 'Debugging payment failure',
+     * });
+     * ```
+     */
+    async replay(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        // Initialize logging
+        await this.getProductBuilder(options.product);
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: options.product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env: options.env,
+            process_id,
+            type: logs_types_1.LogEventTypes.WORKFLOW,
+            parent_tag: options.workflow_id,
+            data: { workflow_id: options.workflow_id, operation: 'replay' },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow replay - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Get original workflow execution state from backend
+            const originalStatus = await this.status({
+                product: options.product,
+                env: options.env,
+                workflow_id: options.workflow_id,
+            });
+            if (!originalStatus) {
+                throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
+            }
+            // Execute with the same input
+            const result = await this.execute({
+                product: options.product,
+                env: options.env,
+                tag: originalStatus.workflow_tag,
+                input: originalStatus.input || {},
+                idempotency_key: options.idempotency_key,
+            });
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow replay - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return Object.assign(Object.assign({}, result), { replayed_from: options.workflow_id });
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow replay - failed', failed_execution: true, data: { workflow_id: options.workflow_id, operation: 'replay', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    /**
+     * Restart a workflow with new or modified input
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.workflows.restart({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   input: { email: 'corrected@email.com' },
+     *   reason: 'Customer email was incorrect',
+     * });
+     * ```
+     */
+    async restart(options) {
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        // Get original workflow execution state from backend
+        const originalStatus = await this.status({
+            product: options.product,
+            env: options.env,
+            workflow_id: options.workflow_id,
+        });
+        if (!originalStatus) {
+            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
+        }
+        // Determine the new input
+        let newInput;
+        if (options.input) {
+            newInput = options.input;
+        }
+        else if (options.input_override && options.merge_input) {
+            newInput = Object.assign(Object.assign({}, (originalStatus.input || {})), options.input_override);
+        }
+        else if (options.input_override) {
+            newInput = options.input_override;
+        }
+        else {
+            newInput = originalStatus.input || {};
+        }
+        // Execute with the new input
+        const result = await this.execute({
+            product: options.product,
+            env: options.env,
+            tag: originalStatus.workflow_tag,
+            input: newInput,
+        });
+        return Object.assign(Object.assign({}, result), { restarted_from: options.workflow_id });
+    }
+    /**
+     * Resume a paused or failed workflow from where it stopped
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.workflows.resume({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   from_checkpoint: 'payment-complete',
+     * });
+     * ```
+     */
+    async resume(options) {
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        // Get original workflow execution state from backend
+        const originalStatus = await this.status({
+            product: options.product,
+            env: options.env,
+            workflow_id: options.workflow_id,
+        });
+        if (!originalStatus) {
+            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
+        }
+        // Fetch the workflow configuration
+        const builder = await this.getProductBuilder(options.product);
+        const workflow = await builder.fetchWorkflow(originalStatus.workflow_tag);
+        if (!workflow) {
+            throw WorkflowError.notFoundError(`Workflow ${originalStatus.workflow_tag} not found`);
+        }
+        // Create executor with resume options
+        const executor = new workflow_executor_1.WorkflowExecutor(this.config, workflow, {
+            product: options.product,
+            env: options.env,
+            tag: originalStatus.workflow_tag,
+            input: Object.assign(Object.assign({}, (originalStatus.input || {})), (options.input || {})),
+        }, this._privateKey);
+        // Resume execution (executor handles skipping completed steps)
+        const result = await executor.resume({
+            completed_steps: originalStatus.completed_steps,
+            state: originalStatus.state,
+            from_checkpoint: options.from_checkpoint,
+            from_step: options.from_step,
+            skip_steps: options.skip_steps,
+        });
+        return Object.assign(Object.assign({}, result), { resumed_from: options.workflow_id, resumed_checkpoint: options.from_checkpoint });
+    }
+    /**
+     * Replay a workflow starting from a specific step
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.workflows.replayFromStep({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   from_step: 'process-payment',
+     * });
+     * ```
+     */
+    async replayFromStep(options) {
+        if (!this.config) {
+            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
+        }
+        // Get original workflow execution state
+        const originalStatus = await this.status({
+            product: options.product,
+            env: options.env,
+            workflow_id: options.workflow_id,
+        });
+        if (!originalStatus) {
+            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
+        }
+        // Fetch the workflow configuration
+        const builder = await this.getProductBuilder(options.product);
+        const workflow = await builder.fetchWorkflow(originalStatus.workflow_tag);
+        if (!workflow) {
+            throw WorkflowError.notFoundError(`Workflow ${originalStatus.workflow_tag} not found`);
+        }
+        // Find steps before from_step to mark as completed
+        const stepIndex = workflow.steps.findIndex((s) => s.tag === options.from_step);
+        if (stepIndex === -1) {
+            throw WorkflowError.validationError(`Step ${options.from_step} not found in workflow`);
+        }
+        const completedSteps = workflow.steps.slice(0, stepIndex).map((s) => s.tag);
+        // Create executor with partial state
+        const executor = new workflow_executor_1.WorkflowExecutor(this.config, workflow, {
+            product: options.product,
+            env: options.env,
+            tag: originalStatus.workflow_tag,
+            input: originalStatus.input || {},
+        }, this._privateKey);
+        // Resume from the specified step with overridden outputs
+        const result = await executor.resume({
+            completed_steps: completedSteps,
+            state: originalStatus.state,
+            step_outputs: options.step_outputs,
+        });
+        return Object.assign(Object.assign({}, result), { replayed_from: options.workflow_id });
+    }
+    // ==================== STATUS & MANAGEMENT ====================
+    /**
+     * Get the status of a workflow execution
+     *
+     * @example
+     * ```ts
+     * const status = await ductape.workflows.status({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     * });
+     * ```
+     */
+    async status(options) {
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.getStatus(options.workflow_id, options.product, options.env, auth);
+        if (!response) {
+            return null;
+        }
+        return {
+            workflow_id: response.workflow_id,
+            workflow_tag: response.workflow_tag,
+            status: response.status,
+            current_step: response.current_step,
+            completed_steps: response.completed_steps,
+            state: response.state,
+            started_at: response.started_at,
+            updated_at: response.updated_at,
+            input: response.input,
+            output: response.output,
+            error: response.error,
+        };
+    }
+    /**
+     * Cancel a running workflow
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.workflows.cancel({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   reason: 'User requested cancellation',
+     * });
+     * ```
+     */
+    async cancel(options) {
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.cancel(options.workflow_id, options.product, options.env, options.reason || 'Cancelled by user', auth);
+        return {
+            cancelled: response.cancelled,
+            rolled_back_steps: response.rolled_back_steps,
+            failed_rollbacks: response.failed_rollbacks,
+        };
+    }
+    /**
+     * Get the execution history of a workflow
+     *
+     * @example
+     * ```ts
+     * const history = await ductape.workflows.history({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     * });
+     * ```
+     */
+    async history(options) {
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.getHistory(options.workflow_id, options.product, options.env, auth);
+        return {
+            workflow_id: response.workflow_id,
+            workflow_tag: response.workflow_tag,
+            status: response.status,
+            events: response.events.map((e) => ({
+                type: e.type,
+                timestamp: e.timestamp,
+                data: e.data,
+            })),
+            checkpoints: response.checkpoints,
+            replays: response.replays,
+            restarts: response.restarts,
+        };
+    }
+    /**
+     * Get detailed information about a specific step
+     *
+     * @example
+     * ```ts
+     * const detail = await ductape.workflows.stepDetail({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     *   step_tag: 'process-payment',
+     * });
+     * ```
+     */
+    async stepDetail(options) {
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.getStepDetail(options.workflow_id, options.step_tag, options.product, options.env, auth);
+        if (!response) {
+            return null;
+        }
+        return {
+            tag: response.tag,
+            name: response.name,
+            status: response.status,
+            input: response.input,
+            output: response.output,
+            error: response.error,
+            attempts: response.attempts,
+            start_time: response.start_time,
+            end_time: response.end_time,
+            duration: response.duration,
+            rollback_status: response.rollback_status,
+            rollback_error: response.rollback_error,
+        };
+    }
+    /**
+     * List all related executions (replays, restarts, resumes)
+     *
+     * @example
+     * ```ts
+     * const related = await ductape.workflows.relatedExecutions({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_id: 'wf-123',
+     * });
+     * ```
+     */
+    async relatedExecutions(options) {
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.getRelatedExecutions(options.workflow_id, options.product, options.env, auth);
+        return {
+            original: response.original,
+            executions: response.executions.map((e) => ({
+                workflow_id: e.workflow_id,
+                type: e.type,
+                status: e.status,
+                created_at: e.created_at,
+                replayed_from: e.replayed_from,
+                restarted_from: e.restarted_from,
+                resumed_from: e.resumed_from,
+            })),
+        };
+    }
+    /**
+     * Compare two workflow executions
+     *
+     * @example
+     * ```ts
+     * const comparison = await ductape.workflows.compare({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   workflow_ids: ['wf-123', 'wf-456'],
+     * });
+     * ```
+     */
+    async compare(options) {
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.compareExecutions(options.workflow_ids, options.product, options.env, auth);
+        return {
+            workflows: response.workflows,
+            input_diff: response.input_diff,
+            step_diffs: response.step_diffs,
+            outcome_diff: response.outcome_diff,
+        };
+    }
+    // ==================== HELPER METHODS ====================
+    /**
+     * Convert IProductWorkflow to IWorkflowConfig
+     */
+    productWorkflowToConfig(workflow) {
+        return {
+            name: workflow.name,
+            tag: workflow.tag,
+            description: workflow.description,
+            input: workflow.input,
+            output: workflow.output,
+            steps: workflow.steps,
+            signals: workflow.signals,
+            queries: workflow.queries,
+            options: workflow.options,
+            envs: workflow.envs,
+        };
+    }
+}
+exports.WorkflowService = WorkflowService;
+// ==================== WORKFLOW COMPILER ====================
+/**
+ * Recording context that captures step definitions during handler execution
+ */
+class RecordingContext {
+    constructor(_input, _workflowTag) {
+        this._input = _input;
+        this._workflowTag = _workflowTag;
+        this._steps = [];
+        this._stepOrder = 0;
+        this._currentStepTag = null;
+        this._pendingRollback = null;
+    }
+    // Readonly workflow metadata
+    get input() {
+        return this._input;
+    }
+    get workflow_id() {
+        return `compile-${this._workflowTag}`;
+    }
+    get workflow_tag() {
+        return this._workflowTag;
+    }
+    get env() {
+        return 'compile';
+    }
+    get product() {
+        return 'compile';
+    }
+    get context() {
+        return {};
+    }
+    get state() {
+        return {};
+    }
+    get steps() {
+        return {};
+    }
+    get completed_steps() {
+        return [];
+    }
+    get current_step() {
+        return this._currentStepTag;
+    }
+    /**
+     * Record a step definition
+     */
+    async step(tag, handler, rollback, options) {
+        this._currentStepTag = tag;
+        this._stepOrder++;
+        // Create step placeholder - will be updated by component calls
+        const step = {
+            tag,
+            type: productsBuilder_types_1.WorkflowStepType.ACTION,
+            event: '',
+            input: {},
+            options,
+        };
+        // Execute handler to capture component calls
+        try {
+            await handler();
+        }
+        catch (e) {
+            // Ignore errors during compilation - we're just tracing
+        }
+        // If rollback was provided, try to capture it
+        if (rollback && this._pendingRollback) {
+            step.rollback = this._pendingRollback;
+            this._pendingRollback = null;
+        }
+        // Only add if step type was set by a component call
+        if (step.event) {
+            this._steps.push(step);
+        }
+        this._currentStepTag = null;
+        // Return mock result
+        return {};
+    }
+    // ==================== COMPONENT CONTEXTS ====================
+    get action() {
+        return {
+            run: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.ACTION, options.action, {
+                    app: options.app,
+                    input: options.input,
+                    options: { retries: options.retries, timeout: options.timeout },
+                });
+                return {};
+                return {};
+            },
+        };
+    }
+    get database() {
+        return {
+            execute: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
+                    database: options.database,
+                    input: options.input,
+                    options: { retries: options.retries, timeout: options.timeout },
+                });
+                return {};
+            },
+            query: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
+                    database: options.database,
+                    input: options.params || {},
+                });
+                return [];
+            },
+            insert: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
+                    database: options.database,
+                    input: { data: options.data },
+                });
+                return {};
+            },
+            update: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
+                    database: options.database,
+                    input: { data: options.data, where: options.where },
+                });
+                return {};
+            },
+            delete: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
+                    database: options.database,
+                    input: { where: options.where },
+                });
+                return true;
+            },
+        };
+    }
+    get graph() {
+        return {
+            execute: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, options.action, {
+                    graph: options.graph,
+                    input: options.input,
+                });
+                return {};
+            },
+            createNode: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'createNode', {
+                    graph: options.graph,
+                    input: { labels: options.labels, properties: options.properties },
+                });
+                return {};
+            },
+            updateNode: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'updateNode', {
+                    graph: options.graph,
+                    input: { id: options.id, properties: options.properties },
+                });
+                return {};
+            },
+            deleteNode: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'deleteNode', {
+                    graph: options.graph,
+                    input: { id: options.id },
+                });
+            },
+            createRelationship: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'createRelationship', {
+                    graph: options.graph,
+                    input: { from: options.from, to: options.to, type: options.type, properties: options.properties },
+                });
+                return {};
+            },
+            deleteRelationship: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'deleteRelationship', {
+                    graph: options.graph,
+                    input: { id: options.id },
+                });
+            },
+            query: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, options.action, {
+                    graph: options.graph,
+                    input: options.params || {},
+                });
+                return [];
+            },
+        };
+    }
+    get notification() {
+        return {
+            send: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
+                    notification: options.notification,
+                    input: options.input,
+                    options: { retries: options.retries },
+                });
+            },
+            email: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
+                    notification: options.notification,
+                    input: { recipients: options.recipients, subject: options.subject, template: options.template },
+                });
+            },
+            push: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
+                    notification: options.notification,
+                    input: { tokens: options.tokens, title: options.title, body: options.body, data: options.data },
+                });
+            },
+            sms: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
+                    notification: options.notification,
+                    input: { phones: options.phones, message: options.message },
+                });
+            },
+        };
+    }
+    get storage() {
+        return {
+            upload: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.STORAGE, options.event, {
+                    storage: options.storage,
+                    input: options.input,
+                    options: { retries: options.retries },
+                });
+                return { file_key: '', url: '' };
+            },
+            download: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.STORAGE, options.event, {
+                    storage: options.storage,
+                    input: options.input,
+                });
+                return { content: '', content_type: '', size: 0 };
+            },
+            delete: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.STORAGE, options.event, {
+                    storage: options.storage,
+                    input: options.input,
+                });
+            },
+        };
+    }
+    get publish() {
+        return {
+            send: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.PUBLISH, options.event, {
+                    broker: options.broker,
+                    input: options.input,
+                    options: { retries: options.retries },
+                });
+            },
+        };
+    }
+    get feature() {
+        return {
+            run: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.FEATURE, options.feature, {
+                    input: options.input,
+                    options: { retries: options.retries, timeout: options.timeout },
+                });
+                return {};
+            },
+        };
+    }
+    get quota() {
+        return {
+            execute: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.QUOTA, 'execute', {
+                    quota: options.quota,
+                    input: options.input,
+                    options: { timeout: options.timeout },
+                });
+                return {};
+            },
+        };
+    }
+    get fallback() {
+        return {
+            execute: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.FALLBACK, 'execute', {
+                    fallback: options.fallback,
+                    input: options.input,
+                    options: { timeout: options.timeout },
+                });
+                return {};
+            },
+        };
+    }
+    get healthcheck() {
+        return {
+            getStatus: async (tag) => {
+                return { status: 'available', lastChecked: new Date().toISOString(), lastLatency: 0 };
+            },
+        };
+    }
+    get transform() {
+        return {
+            size: (obj) => Object.keys(obj).length,
+            length: (arr) => arr.length,
+            parseJson: (str) => JSON.parse(str),
+            stringify: (obj) => JSON.stringify(obj),
+            upper: (str) => str.toUpperCase(),
+            lower: (str) => str.toLowerCase(),
+            trim: (str) => str.trim(),
+            split: (str, separator) => str.split(separator),
+            join: (arr, separator) => arr.join(separator),
+            now: () => Date.now(),
+            formatDate: (date, format) => new Date(date).toISOString(),
+        };
+    }
+    // ==================== DATA REFERENCES ====================
+    variable(app, key) {
+        return `$Variable{${app}}{${key}}`;
+    }
+    constant(app, key) {
+        return `$Constant{${app}}{${key}}`;
+    }
+    token(key) {
+        return `$Secret{${key}}`;
+    }
+    get auth() {
+        return {};
+    }
+    default(value, fallback) {
+        return value !== null && value !== void 0 ? value : fallback;
+    }
+    // ==================== CONTROL FLOW ====================
+    async sleep(duration) {
+        const ms = typeof duration === 'string' ? this._parseDuration(duration) : duration;
+        this._addControlStep(productsBuilder_types_1.WorkflowStepType.SLEEP, 'sleep', { duration: ms });
+    }
+    async waitForSignal(signal, options) {
+        const signals = Array.isArray(signal) ? signal : [signal];
+        const timeout = (options === null || options === void 0 ? void 0 : options.timeout)
+            ? typeof options.timeout === 'string'
+                ? this._parseDuration(options.timeout)
+                : options.timeout
+            : undefined;
+        this._addControlStep(productsBuilder_types_1.WorkflowStepType.WAIT_FOR_SIGNAL, signals[0], {
+            signals,
+            options: timeout ? { timeout } : undefined,
+        });
+        return {};
+    }
+    async checkpoint(name, metadata) {
+        this._addControlStep(productsBuilder_types_1.WorkflowStepType.CHECKPOINT, name, { metadata });
+    }
+    // ==================== STATE MANAGEMENT ====================
+    setState(key, value) {
+        // No-op during compilation
+    }
+    getState(key) {
+        return undefined;
+    }
+    // ==================== LOGGING ====================
+    get log() {
+        return {
+            debug: (message, data) => { },
+            info: (message, data) => { },
+            warn: (message, data) => { },
+            error: (message, data) => { },
+        };
+    }
+    // ==================== CHILD WORKFLOWS ====================
+    async workflow(childId, tag, input, options) {
+        this._addControlStep(productsBuilder_types_1.WorkflowStepType.CHILD_WORKFLOW, 'execute', {
+            workflow: tag,
+            input,
+            options: options
+                ? {
+                    timeout: options.timeout
+                        ? typeof options.timeout === 'string'
+                            ? this._parseDuration(options.timeout)
+                            : options.timeout
+                        : undefined,
+                    retries: options.retries,
+                }
+                : undefined,
+        });
+        return {};
+    }
+    // ==================== ROLLBACK ====================
+    async triggerRollback(reason) {
+        return { success: true, rolled_back_steps: [], reason };
+    }
+    // ==================== INTERNAL HELPERS ====================
+    _updateCurrentStep(type, event, data) {
+        if (!this._currentStepTag)
+            return;
+        // Find or create the step
+        let step = this._steps.find((s) => s.tag === this._currentStepTag);
+        if (!step) {
+            step = {
+                tag: this._currentStepTag,
+                type,
+                event,
+                input: data.input || {},
+            };
+            this._steps.push(step);
+        }
+        // Update step properties
+        step.type = type;
+        step.event = event;
+        if (data.app)
+            step.app = data.app;
+        if (data.database)
+            step.database = data.database;
+        if (data.graph)
+            step.graph = data.graph;
+        if (data.storage)
+            step.storage = data.storage;
+        if (data.notification)
+            step.notification = data.notification;
+        if (data.broker)
+            step.broker = data.broker;
+        if (data.quota)
+            step.quota = data.quota;
+        if (data.fallback)
+            step.fallback = data.fallback;
+        if (data.workflow)
+            step.workflow = data.workflow;
+        if (data.input)
+            step.input = data.input;
+        if (data.options)
+            step.options = Object.assign(Object.assign({}, step.options), data.options);
+    }
+    _addControlStep(type, event, data) {
+        const tag = `${type}-${this._stepOrder++}`;
+        this._steps.push({
+            tag,
+            type,
+            event,
+            input: data,
+        });
+    }
+    _parseDuration(duration) {
+        const match = duration.match(/^(\d+)(ms|s|m|h|d)$/);
+        if (!match)
+            return parseInt(duration, 10) || 0;
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        switch (unit) {
+            case 'ms':
+                return value;
+            case 's':
+                return value * 1000;
+            case 'm':
+                return value * 60 * 1000;
+            case 'h':
+                return value * 60 * 60 * 1000;
+            case 'd':
+                return value * 24 * 60 * 60 * 1000;
+            default:
+                return value;
+        }
+    }
+    /** Get collected steps */
+    getSteps() {
+        return this._steps;
+    }
+}
+/**
+ * Compiles code-first workflow definitions to JSON schema
+ * Uses runtime handler tracing to capture step definitions
+ */
+class WorkflowCompiler {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Compile the workflow definition to JSON schema
+     * Executes the handler with a recording context to capture step definitions
+     */
+    compile() {
+        // Create recording context with mock input
+        const mockInput = {};
+        const recordingCtx = new RecordingContext(mockInput, this.options.tag);
+        // Execute handler to trace step definitions
+        try {
+            // Run the handler synchronously to capture all step calls
+            // Note: This won't await async operations, but will capture the step structure
+            const handlerPromise = this.options.handler(recordingCtx);
+            // For synchronous tracing, we don't need to await
+            // The recording context captures calls as they're made
+            if (handlerPromise && typeof handlerPromise.then === 'function') {
+                // Handler is async - we capture what we can synchronously
+                // For full async tracing, use compileAsync()
+            }
+        }
+        catch (e) {
+            // Ignore errors during compilation - we're tracing structure, not executing
+        }
+        return {
+            name: this.options.name,
+            tag: this.options.tag,
+            description: this.options.description,
+            input: {},
+            output: {},
+            steps: recordingCtx.getSteps(),
+            signals: this.options.signals
+                ? Object.fromEntries(Object.entries(this.options.signals).map(([name, config]) => [name, { name, input: config.input }]))
+                : undefined,
+            queries: this.options.queries
+                ? Object.fromEntries(Object.entries(this.options.queries).map(([name, config]) => {
+                    var _a;
+                    return [
+                        name,
+                        { name, handler: (_a = config.handler) === null || _a === void 0 ? void 0 : _a.toString() },
+                    ];
+                }))
+                : undefined,
+            options: this.options.options,
+            envs: this.options.envs,
+        };
+    }
+    /**
+     * Compile the workflow definition asynchronously
+     * Fully awaits the handler to capture all step definitions
+     */
+    async compileAsync() {
+        // Create recording context with mock input
+        const mockInput = {};
+        const recordingCtx = new RecordingContext(mockInput, this.options.tag);
+        // Execute handler to trace step definitions
+        try {
+            await this.options.handler(recordingCtx);
+        }
+        catch (e) {
+            // Ignore errors during compilation - we're tracing structure, not executing
+        }
+        return {
+            name: this.options.name,
+            tag: this.options.tag,
+            description: this.options.description,
+            input: {},
+            output: {},
+            steps: recordingCtx.getSteps(),
+            signals: this.options.signals
+                ? Object.fromEntries(Object.entries(this.options.signals).map(([name, config]) => [name, { name, input: config.input }]))
+                : undefined,
+            queries: this.options.queries
+                ? Object.fromEntries(Object.entries(this.options.queries).map(([name, config]) => {
+                    var _a;
+                    return [
+                        name,
+                        { name, handler: (_a = config.handler) === null || _a === void 0 ? void 0 : _a.toString() },
+                    ];
+                }))
+                : undefined,
+            options: this.options.options,
+            envs: this.options.envs,
+        };
+    }
+}
+// Export singleton instance for convenience
+exports.workflowService = new WorkflowService();
+// Default export
+exports.default = WorkflowService;
+//# sourceMappingURL=workflows.service.js.map