@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,1034 +0,0 @@
-"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