@ductape/sdk 0.0.4-v51 → 0.0.4-v53

package/dist/database/triggers/trigger-processor.js

@@ -0,0 +1,1034 @@
+"use strict";
+/**
+ * Trigger Processor
+ *
+ * Executes database triggers that integrate with Ductape primitives.
+ * Handles condition evaluation, action execution, and retry logic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trigger = exports.TriggerProcessor = void 0;
+exports.createTriggerProcessor = createTriggerProcessor;
+const trigger_interface_1 = require("../types/trigger.interface");
+/**
+ * Template interpolation for trigger actions
+ * Supports {{field}}, {{record.field}}, {{previousRecord.field}} syntax
+ */
+function interpolateTemplate(template, context) {
+    if (template === null || template === undefined) {
+        return template;
+    }
+    if (typeof template === 'string') {
+        return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+            const value = getNestedValue(context, path.trim());
+            return value !== undefined ? String(value) : match;
+        });
+    }
+    if (Array.isArray(template)) {
+        return template.map((item) => interpolateTemplate(item, context));
+    }
+    if (typeof template === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(template)) {
+            result[key] = interpolateTemplate(value, context);
+        }
+        return result;
+    }
+    return template;
+}
+/**
+ * Get nested value from object using dot notation
+ */
+function getNestedValue(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Sleep utility for retry delays
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Trigger Processor class
+ */
+class TriggerProcessor {
+    constructor(config = {}, ductapeInstance) {
+        this.triggers = new Map();
+        this.config = Object.assign({ defaultTimeout: 30000, parallelExecution: false, maxConcurrency: 5 }, config);
+        this.ductapeInstance = ductapeInstance;
+    }
+    /**
+     * Set the Ductape instance for executing actions
+     */
+    setDuctapeInstance(instance) {
+        this.ductapeInstance = instance;
+    }
+    /**
+     * Register a trigger for a table
+     */
+    register(table, trigger) {
+        const tableTriggers = this.triggers.get(table) || [];
+        tableTriggers.push(trigger);
+        this.triggers.set(table, tableTriggers);
+    }
+    /**
+     * Register multiple triggers
+     */
+    registerAll(triggers) {
+        for (const { table, trigger } of triggers) {
+            this.register(table, trigger);
+        }
+    }
+    /**
+     * Unregister a trigger by name
+     */
+    unregister(table, triggerName) {
+        const tableTriggers = this.triggers.get(table);
+        if (!tableTriggers)
+            return false;
+        const index = tableTriggers.findIndex((t) => t.name === triggerName);
+        if (index === -1)
+            return false;
+        tableTriggers.splice(index, 1);
+        return true;
+    }
+    /**
+     * Get all triggers for a table and event
+     */
+    getTriggersForEvent(table, event) {
+        const tableTriggers = this.triggers.get(table) || [];
+        const globalTriggers = this.triggers.get('*') || [];
+        return [...tableTriggers, ...globalTriggers]
+            .filter((t) => t.enabled !== false && t.events.includes(event))
+            .sort((a, b) => (a.priority || 100) - (b.priority || 100));
+    }
+    /**
+     * Execute all triggers for an event
+     */
+    async executeTriggers(event, context) {
+        const triggers = this.getTriggersForEvent(context.table, event);
+        const results = [];
+        // Call beforeTrigger hook if defined
+        for (const trigger of triggers) {
+            if (this.config.beforeTrigger) {
+                const shouldExecute = await this.config.beforeTrigger(context, trigger);
+                if (!shouldExecute) {
+                    results.push({
+                        trigger: trigger.name,
+                        event,
+                        success: true,
+                        actions: [],
+                        duration: 0,
+                        skipped: true,
+                        skipReason: 'Skipped by beforeTrigger hook',
+                    });
+                    continue;
+                }
+            }
+            const result = await this.executeTrigger(trigger, context);
+            results.push(result);
+            // Call afterTrigger hook if defined
+            if (this.config.afterTrigger) {
+                this.config.afterTrigger(result, context);
+            }
+        }
+        return results;
+    }
+    /**
+     * Execute a single trigger
+     */
+    async executeTrigger(trigger, context) {
+        var _a;
+        const startTime = Date.now();
+        // Check trigger condition
+        if (trigger.condition && !this.evaluateCondition(trigger.condition, context)) {
+            return {
+                trigger: trigger.name,
+                event: context.event,
+                success: true,
+                actions: [],
+                duration: Date.now() - startTime,
+                skipped: true,
+                skipReason: 'Condition not met',
+            };
+        }
+        const actionResults = [];
+        let overallSuccess = true;
+        // Execute actions
+        if (this.config.parallelExecution) {
+            // Parallel execution
+            const promises = trigger.actions.map((action) => this.executeAction(action, context, trigger));
+            const results = await Promise.allSettled(promises);
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                if (result.status === 'fulfilled') {
+                    actionResults.push(result.value);
+                    if (!result.value.success)
+                        overallSuccess = false;
+                }
+                else {
+                    actionResults.push({
+                        action: trigger.actions[i].name || trigger.actions[i].type,
+                        success: false,
+                        error: ((_a = result.reason) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error',
+                        duration: 0,
+                    });
+                    overallSuccess = false;
+                }
+            }
+        }
+        else {
+            // Sequential execution
+            for (const action of trigger.actions) {
+                // Check action condition
+                if (action.condition && !this.evaluateCondition(action.condition, context)) {
+                    actionResults.push({
+                        action: action.name || action.type,
+                        success: true,
+                        duration: 0,
+                        result: { skipped: true, reason: 'Condition not met' },
+                    });
+                    continue;
+                }
+                const result = await this.executeAction(action, context, trigger);
+                actionResults.push(result);
+                if (!result.success && !action.continueOnError) {
+                    overallSuccess = false;
+                    break;
+                }
+            }
+        }
+        return {
+            trigger: trigger.name,
+            event: context.event,
+            success: overallSuccess,
+            actions: actionResults,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Execute a single action with retry support
+     */
+    async executeAction(action, context, trigger) {
+        const startTime = Date.now();
+        const actionName = action.name || action.type;
+        const retry = action.retry || this.config.defaultRetry;
+        const timeout = action.timeout || this.config.defaultTimeout || 30000;
+        let attempts = 0;
+        let lastError;
+        const maxAttempts = (retry === null || retry === void 0 ? void 0 : retry.maxAttempts) || 1;
+        while (attempts < maxAttempts) {
+            attempts++;
+            try {
+                // Execute with timeout
+                const result = await Promise.race([
+                    this.executeActionByType(action, context),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Action timeout')), timeout)),
+                ]);
+                return {
+                    action: actionName,
+                    success: true,
+                    result,
+                    duration: Date.now() - startTime,
+                    retries: attempts - 1,
+                };
+            }
+            catch (error) {
+                lastError = error;
+                // Check if we should retry
+                if (retry && attempts < maxAttempts) {
+                    const shouldRetry = !retry.retryOn ||
+                        retry.retryOn.some((errType) => lastError.message.includes(errType));
+                    if (shouldRetry) {
+                        const delay = this.calculateRetryDelay(attempts, retry);
+                        await sleep(delay);
+                        continue;
+                    }
+                }
+                // Call global error handler if defined
+                if (this.config.onError) {
+                    this.config.onError(lastError, context, trigger);
+                }
+                return {
+                    action: actionName,
+                    success: false,
+                    error: lastError.message,
+                    duration: Date.now() - startTime,
+                    retries: attempts - 1,
+                };
+            }
+        }
+        return {
+            action: actionName,
+            success: false,
+            error: (lastError === null || lastError === void 0 ? void 0 : lastError.message) || 'Max retries exceeded',
+            duration: Date.now() - startTime,
+            retries: attempts - 1,
+        };
+    }
+    /**
+     * Calculate retry delay with exponential backoff
+     */
+    calculateRetryDelay(attempt, retry) {
+        const initialDelay = retry.initialDelay || 1000;
+        const maxDelay = retry.maxDelay || 30000;
+        const multiplier = retry.backoffMultiplier || 2;
+        const delay = initialDelay * Math.pow(multiplier, attempt - 1);
+        return Math.min(delay, maxDelay);
+    }
+    /**
+     * Execute action based on type
+     */
+    async executeActionByType(action, context) {
+        switch (action.type) {
+            // Database actions
+            case trigger_interface_1.TriggerActionType.DATABASE_INSERT:
+            case trigger_interface_1.TriggerActionType.DATABASE_UPDATE:
+            case trigger_interface_1.TriggerActionType.DATABASE_DELETE:
+            case trigger_interface_1.TriggerActionType.DATABASE_QUERY:
+                return this.executeDatabaseAction(action, context);
+            // Storage actions
+            case trigger_interface_1.TriggerActionType.STORAGE_UPLOAD:
+            case trigger_interface_1.TriggerActionType.STORAGE_DELETE:
+            case trigger_interface_1.TriggerActionType.STORAGE_COPY:
+                return this.executeStorageAction(action, context);
+            // Notification actions
+            case trigger_interface_1.TriggerActionType.NOTIFICATION_EMAIL:
+            case trigger_interface_1.TriggerActionType.NOTIFICATION_SMS:
+            case trigger_interface_1.TriggerActionType.NOTIFICATION_PUSH:
+            case trigger_interface_1.TriggerActionType.NOTIFICATION_CALLBACK:
+                return this.executeNotificationAction(action, context);
+            // Broker actions
+            case trigger_interface_1.TriggerActionType.BROKER_PUBLISH:
+                return this.executeBrokerAction(action, context);
+            // Cache actions
+            case trigger_interface_1.TriggerActionType.CACHE_SET:
+            case trigger_interface_1.TriggerActionType.CACHE_INVALIDATE:
+            case trigger_interface_1.TriggerActionType.CACHE_DELETE:
+                return this.executeCacheAction(action, context);
+            // Workflow actions
+            case trigger_interface_1.TriggerActionType.WORKFLOW_EXECUTE:
+            case trigger_interface_1.TriggerActionType.WORKFLOW_DISPATCH:
+                return this.executeWorkflowAction(action, context);
+            // App action execution
+            case trigger_interface_1.TriggerActionType.ACTION_EXECUTE:
+                return this.executeAppAction(action, context);
+            // Agent actions
+            case trigger_interface_1.TriggerActionType.AGENT_RUN:
+                return this.executeAgentAction(action, context);
+            // Resilience actions
+            case trigger_interface_1.TriggerActionType.QUOTA_RUN:
+            case trigger_interface_1.TriggerActionType.FALLBACK_RUN:
+            case trigger_interface_1.TriggerActionType.HEALTHCHECK_RUN:
+                return this.executeResilienceAction(action, context);
+            // Log actions
+            case trigger_interface_1.TriggerActionType.LOG_CREATE:
+                return this.executeLogAction(action, context);
+            // Session actions
+            case trigger_interface_1.TriggerActionType.SESSION_REVOKE:
+                return this.executeSessionAction(action, context);
+            // Vector actions
+            case trigger_interface_1.TriggerActionType.VECTOR_UPSERT:
+            case trigger_interface_1.TriggerActionType.VECTOR_DELETE:
+                return this.executeVectorAction(action, context);
+            // Custom actions
+            case trigger_interface_1.TriggerActionType.CUSTOM_FUNCTION:
+                return this.executeCustomAction(action, context);
+            case trigger_interface_1.TriggerActionType.CUSTOM_HTTP:
+                return this.executeHttpAction(action, context);
+            default:
+                throw new Error(`Unknown action type: ${action.type}`);
+        }
+    }
+    /**
+     * Evaluate a condition against context
+     */
+    evaluateCondition(condition, context) {
+        // Custom function condition
+        if (condition.custom) {
+            return condition.custom(context);
+        }
+        // Compound conditions
+        if (condition.$and) {
+            return condition.$and.every((c) => this.isConditionClause(c)
+                ? this.evaluateClause(c, context)
+                : this.evaluateCondition(c, context));
+        }
+        if (condition.$or) {
+            return condition.$or.some((c) => this.isConditionClause(c)
+                ? this.evaluateClause(c, context)
+                : this.evaluateCondition(c, context));
+        }
+        if (condition.$not) {
+            return this.isConditionClause(condition.$not)
+                ? !this.evaluateClause(condition.$not, context)
+                : !this.evaluateCondition(condition.$not, context);
+        }
+        // Simple condition
+        if (condition.field && condition.operator) {
+            return this.evaluateClause(condition, context);
+        }
+        return true;
+    }
+    /**
+     * Check if a condition is a simple clause
+     */
+    isConditionClause(condition) {
+        return 'field' in condition && 'operator' in condition;
+    }
+    /**
+     * Evaluate a single condition clause
+     */
+    evaluateClause(clause, context) {
+        var _a, _b, _c, _d, _e, _f;
+        const fieldValue = getNestedValue(Object.assign({ record: context.record, previousRecord: context.previousRecord }, context), clause.field);
+        switch (clause.operator) {
+            case trigger_interface_1.ConditionOperator.EQUALS:
+                return fieldValue === clause.value;
+            case trigger_interface_1.ConditionOperator.NOT_EQUALS:
+                return fieldValue !== clause.value;
+            case trigger_interface_1.ConditionOperator.GREATER_THAN:
+                return fieldValue > clause.value;
+            case trigger_interface_1.ConditionOperator.GREATER_THAN_OR_EQUALS:
+                return fieldValue >= clause.value;
+            case trigger_interface_1.ConditionOperator.LESS_THAN:
+                return fieldValue < clause.value;
+            case trigger_interface_1.ConditionOperator.LESS_THAN_OR_EQUALS:
+                return fieldValue <= clause.value;
+            case trigger_interface_1.ConditionOperator.IN:
+                return Array.isArray(clause.value) && clause.value.includes(fieldValue);
+            case trigger_interface_1.ConditionOperator.NOT_IN:
+                return Array.isArray(clause.value) && !clause.value.includes(fieldValue);
+            case trigger_interface_1.ConditionOperator.CONTAINS:
+                return String(fieldValue).includes(String(clause.value));
+            case trigger_interface_1.ConditionOperator.STARTS_WITH:
+                return String(fieldValue).startsWith(String(clause.value));
+            case trigger_interface_1.ConditionOperator.ENDS_WITH:
+                return String(fieldValue).endsWith(String(clause.value));
+            case trigger_interface_1.ConditionOperator.MATCHES:
+                return new RegExp(clause.value).test(String(fieldValue));
+            case trigger_interface_1.ConditionOperator.IS_NULL:
+                return fieldValue === null || fieldValue === undefined;
+            case trigger_interface_1.ConditionOperator.IS_NOT_NULL:
+                return fieldValue !== null && fieldValue !== undefined;
+            case trigger_interface_1.ConditionOperator.IS_EMPTY:
+                return (fieldValue === '' ||
+                    fieldValue === null ||
+                    fieldValue === undefined ||
+                    (Array.isArray(fieldValue) && fieldValue.length === 0));
+            case trigger_interface_1.ConditionOperator.IS_NOT_EMPTY:
+                return (fieldValue !== '' &&
+                    fieldValue !== null &&
+                    fieldValue !== undefined &&
+                    !(Array.isArray(fieldValue) && fieldValue.length === 0));
+            case trigger_interface_1.ConditionOperator.CHANGED:
+                return (_b = (_a = context.changedFields) === null || _a === void 0 ? void 0 : _a.includes(clause.field.replace('record.', ''))) !== null && _b !== void 0 ? _b : false;
+            case trigger_interface_1.ConditionOperator.NOT_CHANGED:
+                return !((_d = (_c = context.changedFields) === null || _c === void 0 ? void 0 : _c.includes(clause.field.replace('record.', ''))) !== null && _d !== void 0 ? _d : false);
+            case trigger_interface_1.ConditionOperator.CHANGED_TO:
+                const currentVal = getNestedValue(context, 'record.' + clause.field.replace('record.', ''));
+                const changed = (_e = context.changedFields) === null || _e === void 0 ? void 0 : _e.includes(clause.field.replace('record.', ''));
+                return changed === true && currentVal === clause.value;
+            case trigger_interface_1.ConditionOperator.CHANGED_FROM:
+                const prevVal = getNestedValue(context, 'previousRecord.' + clause.field.replace('record.', ''));
+                const wasChanged = (_f = context.changedFields) === null || _f === void 0 ? void 0 : _f.includes(clause.field.replace('record.', ''));
+                return wasChanged === true && prevVal === clause.value;
+            default:
+                return false;
+        }
+    }
+    // ==================== ACTION EXECUTORS ====================
+    /**
+     * Execute database action
+     */
+    async executeDatabaseAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.databases)) {
+            throw new Error('Ductape instance with databases not available');
+        }
+        const db = this.ductapeInstance.databases;
+        const data = interpolateTemplate(action.data, context);
+        const where = interpolateTemplate(action.where, context);
+        switch (action.type) {
+            case trigger_interface_1.TriggerActionType.DATABASE_INSERT:
+                return db.insert({
+                    table: action.table,
+                    data,
+                });
+            case trigger_interface_1.TriggerActionType.DATABASE_UPDATE:
+                return db.update({
+                    table: action.table,
+                    data,
+                    where,
+                });
+            case trigger_interface_1.TriggerActionType.DATABASE_DELETE:
+                return db.delete({
+                    table: action.table,
+                    where,
+                });
+            case trigger_interface_1.TriggerActionType.DATABASE_QUERY:
+                return db.find({
+                    table: action.table,
+                    where,
+                });
+        }
+    }
+    /**
+     * Execute storage action
+     */
+    async executeStorageAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.storage)) {
+            throw new Error('Ductape instance with storage not available');
+        }
+        const storage = this.ductapeInstance.storage;
+        const path = interpolateTemplate(action.path, context);
+        switch (action.type) {
+            case trigger_interface_1.TriggerActionType.STORAGE_UPLOAD:
+                const dataField = action.dataField || 'file';
+                const fileData = getNestedValue(context, `record.${dataField}`);
+                return storage.upload({
+                    storage: action.storage,
+                    path,
+                    data: fileData,
+                    mimeType: action.mimeType,
+                });
+            case trigger_interface_1.TriggerActionType.STORAGE_DELETE:
+                return storage.delete({
+                    storage: action.storage,
+                    path,
+                });
+            case trigger_interface_1.TriggerActionType.STORAGE_COPY:
+                const sourcePath = interpolateTemplate(action.sourcePath, context);
+                return storage.copy({
+                    storage: action.storage,
+                    sourcePath,
+                    destinationPath: path,
+                });
+        }
+    }
+    /**
+     * Execute notification action
+     */
+    async executeNotificationAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.notifications)) {
+            throw new Error('Ductape instance with notifications not available');
+        }
+        const notifications = this.ductapeInstance.notifications;
+        const recipients = interpolateTemplate(action.recipients, context);
+        const template = interpolateTemplate(action.template, context);
+        const body = interpolateTemplate(action.body, context);
+        const subject = interpolateTemplate(action.subject, context);
+        return notifications.send({
+            notification: action.notification,
+            recipients: Array.isArray(recipients) ? recipients : [recipients],
+            template,
+            body,
+            subject,
+            data: action.data,
+        });
+    }
+    /**
+     * Execute broker action
+     */
+    async executeBrokerAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.brokers)) {
+            throw new Error('Ductape instance with brokers not available');
+        }
+        const brokers = this.ductapeInstance.brokers;
+        const message = interpolateTemplate(action.message, context);
+        const headers = interpolateTemplate(action.headers, context);
+        const idempotencyKey = interpolateTemplate(action.idempotencyKey, context);
+        return brokers.publish({
+            event: action.event,
+            message,
+            headers,
+            idempotencyKey,
+        });
+    }
+    /**
+     * Execute cache action
+     */
+    async executeCacheAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.cache)) {
+            throw new Error('Ductape instance with cache not available');
+        }
+        const cache = this.ductapeInstance.cache;
+        const key = interpolateTemplate(action.key, context);
+        const value = interpolateTemplate(action.value, context);
+        const pattern = interpolateTemplate(action.pattern, context);
+        switch (action.type) {
+            case trigger_interface_1.TriggerActionType.CACHE_SET:
+                return cache.set({
+                    cache: action.cache,
+                    key,
+                    value,
+                    ttl: action.ttl,
+                });
+            case trigger_interface_1.TriggerActionType.CACHE_INVALIDATE:
+                return cache.invalidate({
+                    cache: action.cache,
+                    pattern: pattern || key,
+                });
+            case trigger_interface_1.TriggerActionType.CACHE_DELETE:
+                return cache.delete({
+                    cache: action.cache,
+                    key,
+                });
+        }
+    }
+    /**
+     * Execute workflow action
+     */
+    async executeWorkflowAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.workflows)) {
+            throw new Error('Ductape instance with workflows not available');
+        }
+        const workflows = this.ductapeInstance.workflows;
+        const input = interpolateTemplate(action.input, context);
+        if (action.type === trigger_interface_1.TriggerActionType.WORKFLOW_EXECUTE && action.waitForCompletion) {
+            return workflows.execute({
+                workflow: action.workflow,
+                input,
+            });
+        }
+        else {
+            return workflows.dispatch({
+                workflow: action.workflow,
+                input,
+            });
+        }
+    }
+    /**
+     * Execute app action
+     */
+    async executeAppAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.apps)) {
+            throw new Error('Ductape instance with apps not available');
+        }
+        const apps = this.ductapeInstance.apps;
+        const input = interpolateTemplate(action.input, context);
+        return apps.run({
+            app: action.app,
+            action: action.action,
+            input,
+        });
+    }
+    /**
+     * Execute agent action
+     */
+    async executeAgentAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.agents)) {
+            throw new Error('Ductape instance with agents not available');
+        }
+        const agents = this.ductapeInstance.agents;
+        const prompt = interpolateTemplate(action.prompt, context);
+        const input = interpolateTemplate(action.input, context);
+        return agents.run({
+            agent: action.agent,
+            prompt,
+            input,
+        });
+    }
+    /**
+     * Execute resilience action (quota/fallback/healthcheck)
+     */
+    async executeResilienceAction(action, context) {
+        var _a, _b, _c;
+        const input = interpolateTemplate(action.input, context);
+        switch (action.type) {
+            case trigger_interface_1.TriggerActionType.QUOTA_RUN:
+                if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.quotas)) {
+                    throw new Error('Ductape instance with quotas not available');
+                }
+                return this.ductapeInstance.quotas.run({
+                    tag: action.tag,
+                    input,
+                });
+            case trigger_interface_1.TriggerActionType.FALLBACK_RUN:
+                if (!((_b = this.ductapeInstance) === null || _b === void 0 ? void 0 : _b.fallbacks)) {
+                    throw new Error('Ductape instance with fallbacks not available');
+                }
+                return this.ductapeInstance.fallbacks.run({
+                    tag: action.tag,
+                    input,
+                });
+            case trigger_interface_1.TriggerActionType.HEALTHCHECK_RUN:
+                if (!((_c = this.ductapeInstance) === null || _c === void 0 ? void 0 : _c.healthchecks)) {
+                    throw new Error('Ductape instance with healthchecks not available');
+                }
+                return this.ductapeInstance.healthchecks.run({
+                    tag: action.tag,
+                    input,
+                });
+        }
+    }
+    /**
+     * Execute log action
+     */
+    async executeLogAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.logs)) {
+            throw new Error('Ductape instance with logs not available');
+        }
+        const logs = this.ductapeInstance.logs;
+        const message = interpolateTemplate(action.message, context);
+        const data = interpolateTemplate(action.data, context);
+        return logs.create({
+            level: action.level || 'info',
+            message,
+            data,
+            metadata: {
+                trigger: true,
+                table: context.table,
+                event: context.event,
+                operation: context.operation,
+            },
+        });
+    }
+    /**
+     * Execute session action
+     */
+    async executeSessionAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.sessions)) {
+            throw new Error('Ductape instance with sessions not available');
+        }
+        const sessions = this.ductapeInstance.sessions;
+        const userIdField = action.userIdField || 'userId';
+        const sessionIdField = action.sessionIdField || 'sessionId';
+        const userId = getNestedValue(context, `record.${userIdField}`);
+        const sessionId = getNestedValue(context, `record.${sessionIdField}`);
+        return sessions.revoke({
+            session: action.session,
+            userId,
+            sessionId,
+        });
+    }
+    /**
+     * Execute vector action
+     */
+    async executeVectorAction(action, context) {
+        var _a;
+        if (!((_a = this.ductapeInstance) === null || _a === void 0 ? void 0 : _a.vectors)) {
+            throw new Error('Ductape instance with vectors not available');
+        }
+        const vectors = this.ductapeInstance.vectors;
+        const id = interpolateTemplate(action.id, context);
+        const metadata = interpolateTemplate(action.metadata, context);
+        switch (action.type) {
+            case trigger_interface_1.TriggerActionType.VECTOR_UPSERT:
+                const vectorField = action.vectorField || 'embedding';
+                const vector = getNestedValue(context, `record.${vectorField}`);
+                return vectors.upsert({
+                    vector: action.vector,
+                    namespace: action.namespace,
+                    id,
+                    values: vector,
+                    metadata,
+                });
+            case trigger_interface_1.TriggerActionType.VECTOR_DELETE:
+                return vectors.delete({
+                    vector: action.vector,
+                    namespace: action.namespace,
+                    id,
+                });
+        }
+    }
+    /**
+     * Execute custom function action
+     */
+    async executeCustomAction(action, context) {
+        return action.handler(context);
+    }
+    /**
+     * Execute HTTP action
+     */
+    async executeHttpAction(action, context) {
+        const url = interpolateTemplate(action.url, context);
+        const headers = interpolateTemplate(action.headers, context) || {};
+        const body = interpolateTemplate(action.body, context);
+        const query = interpolateTemplate(action.query, context);
+        // Build URL with query params
+        const urlObj = new URL(url);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                urlObj.searchParams.set(key, String(value));
+            }
+        }
+        const response = await fetch(urlObj.toString(), {
+            method: action.method,
+            headers: Object.assign({ 'Content-Type': 'application/json' }, headers),
+            body: action.method !== 'GET' ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+}
+exports.TriggerProcessor = TriggerProcessor;
+/**
+ * Create a trigger processor instance
+ */
+function createTriggerProcessor(config, ductapeInstance) {
+    return new TriggerProcessor(config, ductapeInstance);
+}
+/**
+ * Helper to build trigger definitions
+ */
+exports.Trigger = {
+    /**
+     * Create a database action
+     */
+    database: {
+        insert: (table, data) => ({
+            type: trigger_interface_1.TriggerActionType.DATABASE_INSERT,
+            table,
+            data,
+        }),
+        update: (table, data, where) => ({
+            type: trigger_interface_1.TriggerActionType.DATABASE_UPDATE,
+            table,
+            data,
+            where,
+        }),
+        delete: (table, where) => ({
+            type: trigger_interface_1.TriggerActionType.DATABASE_DELETE,
+            table,
+            where,
+        }),
+        query: (table, where) => ({
+            type: trigger_interface_1.TriggerActionType.DATABASE_QUERY,
+            table,
+            where,
+        }),
+    },
+    /**
+     * Create a storage action
+     */
+    storage: {
+        upload: (storage, path, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.STORAGE_UPLOAD, storage,
+            path }, options)),
+        delete: (storage, path) => ({
+            type: trigger_interface_1.TriggerActionType.STORAGE_DELETE,
+            storage,
+            path,
+        }),
+        copy: (storage, sourcePath, destinationPath) => ({
+            type: trigger_interface_1.TriggerActionType.STORAGE_COPY,
+            storage,
+            path: destinationPath,
+            sourcePath,
+        }),
+    },
+    /**
+     * Create a notification action
+     */
+    notification: {
+        email: (notification, recipients, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.NOTIFICATION_EMAIL, notification,
+            recipients }, options)),
+        sms: (notification, recipients, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.NOTIFICATION_SMS, notification,
+            recipients }, options)),
+        push: (notification, recipients, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.NOTIFICATION_PUSH, notification,
+            recipients }, options)),
+        callback: (notification, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.NOTIFICATION_CALLBACK, notification }, options)),
+    },
+    /**
+     * Create a broker action
+     */
+    broker: {
+        publish: (event, message, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.BROKER_PUBLISH, event,
+            message }, options)),
+    },
+    /**
+     * Create a cache action
+     */
+    cache: {
+        set: (cache, key, value, ttl) => ({
+            type: trigger_interface_1.TriggerActionType.CACHE_SET,
+            cache,
+            key,
+            value,
+            ttl,
+        }),
+        invalidate: (cache, pattern) => ({
+            type: trigger_interface_1.TriggerActionType.CACHE_INVALIDATE,
+            cache,
+            key: pattern,
+            pattern,
+        }),
+        delete: (cache, key) => ({
+            type: trigger_interface_1.TriggerActionType.CACHE_DELETE,
+            cache,
+            key,
+        }),
+    },
+    /**
+     * Create a workflow action
+     */
+    workflow: {
+        execute: (workflow, input) => ({
+            type: trigger_interface_1.TriggerActionType.WORKFLOW_EXECUTE,
+            workflow,
+            input,
+            waitForCompletion: true,
+        }),
+        dispatch: (workflow, input) => ({
+            type: trigger_interface_1.TriggerActionType.WORKFLOW_DISPATCH,
+            workflow,
+            input,
+            waitForCompletion: false,
+        }),
+    },
+    /**
+     * Create an app action
+     */
+    action: {
+        execute: (app, action, input) => ({
+            type: trigger_interface_1.TriggerActionType.ACTION_EXECUTE,
+            app,
+            action,
+            input,
+        }),
+    },
+    /**
+     * Create an agent action
+     */
+    agent: {
+        run: (agent, prompt, input) => ({
+            type: trigger_interface_1.TriggerActionType.AGENT_RUN,
+            agent,
+            prompt,
+            input,
+        }),
+    },
+    /**
+     * Create a log action
+     */
+    log: {
+        debug: (message, data) => ({
+            type: trigger_interface_1.TriggerActionType.LOG_CREATE,
+            level: 'debug',
+            message,
+            data,
+        }),
+        info: (message, data) => ({
+            type: trigger_interface_1.TriggerActionType.LOG_CREATE,
+            level: 'info',
+            message,
+            data,
+        }),
+        warn: (message, data) => ({
+            type: trigger_interface_1.TriggerActionType.LOG_CREATE,
+            level: 'warn',
+            message,
+            data,
+        }),
+        error: (message, data) => ({
+            type: trigger_interface_1.TriggerActionType.LOG_CREATE,
+            level: 'error',
+            message,
+            data,
+        }),
+    },
+    /**
+     * Create an HTTP action
+     */
+    http: {
+        get: (url, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.CUSTOM_HTTP, url, method: 'GET' }, options)),
+        post: (url, body, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.CUSTOM_HTTP, url, method: 'POST', body }, options)),
+        put: (url, body, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.CUSTOM_HTTP, url, method: 'PUT', body }, options)),
+        patch: (url, body, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.CUSTOM_HTTP, url, method: 'PATCH', body }, options)),
+        delete: (url, options) => (Object.assign({ type: trigger_interface_1.TriggerActionType.CUSTOM_HTTP, url, method: 'DELETE' }, options)),
+    },
+    /**
+     * Create a custom function action
+     */
+    custom: (handler) => ({
+        type: trigger_interface_1.TriggerActionType.CUSTOM_FUNCTION,
+        handler,
+    }),
+    /**
+     * Condition builders
+     */
+    when: {
+        field: (field) => ({
+            equals: (value) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.EQUALS,
+                value,
+            }),
+            notEquals: (value) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.NOT_EQUALS,
+                value,
+            }),
+            greaterThan: (value) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.GREATER_THAN,
+                value,
+            }),
+            lessThan: (value) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.LESS_THAN,
+                value,
+            }),
+            in: (values) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.IN,
+                value: values,
+            }),
+            contains: (value) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.CONTAINS,
+                value,
+            }),
+            isNull: () => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.IS_NULL,
+            }),
+            isNotNull: () => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.IS_NOT_NULL,
+            }),
+            changed: () => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.CHANGED,
+            }),
+            changedTo: (value) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.CHANGED_TO,
+                value,
+            }),
+            changedFrom: (value) => ({
+                field,
+                operator: trigger_interface_1.ConditionOperator.CHANGED_FROM,
+                value,
+            }),
+        }),
+        and: (...conditions) => ({
+            $and: conditions,
+        }),
+        or: (...conditions) => ({
+            $or: conditions,
+        }),
+        not: (condition) => ({
+            $not: condition,
+        }),
+    },
+};
+//# sourceMappingURL=trigger-processor.js.map