@ductape/sdk 0.0.4-v51 → 0.0.4-v53

package/dist/database/triggers/trigger-processor.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Trigger Processor
+ *
+ * Executes database triggers that integrate with Ductape primitives.
+ * Handles condition evaluation, action execution, and retry logic.
+ */
+import { TriggerEvent, ITriggerDefinition, ITriggerCondition, ITriggerContext, ITriggerResult, ITriggerConfig, IConditionClause, ITriggerDatabaseAction, ITriggerStorageAction, ITriggerNotificationAction, ITriggerBrokerAction, ITriggerCacheAction, ITriggerWorkflowAction, ITriggerActionExecuteAction, ITriggerAgentAction, ITriggerLogAction, ITriggerCustomAction, ITriggerHttpAction } from '../types/trigger.interface';
+/**
+ * Trigger Processor class
+ */
+export declare class TriggerProcessor {
+    private triggers;
+    private config;
+    private ductapeInstance;
+    constructor(config?: ITriggerConfig, ductapeInstance?: any);
+    /**
+     * Set the Ductape instance for executing actions
+     */
+    setDuctapeInstance(instance: any): void;
+    /**
+     * Register a trigger for a table
+     */
+    register(table: string, trigger: ITriggerDefinition): void;
+    /**
+     * Register multiple triggers
+     */
+    registerAll(triggers: Array<{
+        table: string;
+        trigger: ITriggerDefinition;
+    }>): void;
+    /**
+     * Unregister a trigger by name
+     */
+    unregister(table: string, triggerName: string): boolean;
+    /**
+     * Get all triggers for a table and event
+     */
+    getTriggersForEvent(table: string, event: TriggerEvent): ITriggerDefinition[];
+    /**
+     * Execute all triggers for an event
+     */
+    executeTriggers(event: TriggerEvent, context: ITriggerContext): Promise<ITriggerResult[]>;
+    /**
+     * Execute a single trigger
+     */
+    executeTrigger(trigger: ITriggerDefinition, context: ITriggerContext): Promise<ITriggerResult>;
+    /**
+     * Execute a single action with retry support
+     */
+    private executeAction;
+    /**
+     * Calculate retry delay with exponential backoff
+     */
+    private calculateRetryDelay;
+    /**
+     * Execute action based on type
+     */
+    private executeActionByType;
+    /**
+     * Evaluate a condition against context
+     */
+    evaluateCondition(condition: ITriggerCondition, context: ITriggerContext): boolean;
+    /**
+     * Check if a condition is a simple clause
+     */
+    private isConditionClause;
+    /**
+     * Evaluate a single condition clause
+     */
+    private evaluateClause;
+    /**
+     * Execute database action
+     */
+    private executeDatabaseAction;
+    /**
+     * Execute storage action
+     */
+    private executeStorageAction;
+    /**
+     * Execute notification action
+     */
+    private executeNotificationAction;
+    /**
+     * Execute broker action
+     */
+    private executeBrokerAction;
+    /**
+     * Execute cache action
+     */
+    private executeCacheAction;
+    /**
+     * Execute workflow action
+     */
+    private executeWorkflowAction;
+    /**
+     * Execute app action
+     */
+    private executeAppAction;
+    /**
+     * Execute agent action
+     */
+    private executeAgentAction;
+    /**
+     * Execute resilience action (quota/fallback/healthcheck)
+     */
+    private executeResilienceAction;
+    /**
+     * Execute log action
+     */
+    private executeLogAction;
+    /**
+     * Execute session action
+     */
+    private executeSessionAction;
+    /**
+     * Execute vector action
+     */
+    private executeVectorAction;
+    /**
+     * Execute custom function action
+     */
+    private executeCustomAction;
+    /**
+     * Execute HTTP action
+     */
+    private executeHttpAction;
+}
+/**
+ * Create a trigger processor instance
+ */
+export declare function createTriggerProcessor(config?: ITriggerConfig, ductapeInstance?: any): TriggerProcessor;
+/**
+ * Helper to build trigger definitions
+ */
+export declare const Trigger: {
+    /**
+     * Create a database action
+     */
+    database: {
+        insert: (table: string, data: Record<string, any> | string) => ITriggerDatabaseAction;
+        update: (table: string, data: Record<string, any> | string, where: Record<string, any> | string) => ITriggerDatabaseAction;
+        delete: (table: string, where: Record<string, any> | string) => ITriggerDatabaseAction;
+        query: (table: string, where: Record<string, any> | string) => ITriggerDatabaseAction;
+    };
+    /**
+     * Create a storage action
+     */
+    storage: {
+        upload: (storage: string, path: string, options?: Partial<ITriggerStorageAction>) => ITriggerStorageAction;
+        delete: (storage: string, path: string) => ITriggerStorageAction;
+        copy: (storage: string, sourcePath: string, destinationPath: string) => ITriggerStorageAction;
+    };
+    /**
+     * Create a notification action
+     */
+    notification: {
+        email: (notification: string, recipients: string | string[], options?: Partial<ITriggerNotificationAction>) => ITriggerNotificationAction;
+        sms: (notification: string, recipients: string | string[], options?: Partial<ITriggerNotificationAction>) => ITriggerNotificationAction;
+        push: (notification: string, recipients: string | string[], options?: Partial<ITriggerNotificationAction>) => ITriggerNotificationAction;
+        callback: (notification: string, options?: Partial<ITriggerNotificationAction>) => ITriggerNotificationAction;
+    };
+    /**
+     * Create a broker action
+     */
+    broker: {
+        publish: (event: string, message: Record<string, any> | string, options?: Partial<ITriggerBrokerAction>) => ITriggerBrokerAction;
+    };
+    /**
+     * Create a cache action
+     */
+    cache: {
+        set: (cache: string, key: string, value: any, ttl?: number) => ITriggerCacheAction;
+        invalidate: (cache: string, pattern: string) => ITriggerCacheAction;
+        delete: (cache: string, key: string) => ITriggerCacheAction;
+    };
+    /**
+     * Create a workflow action
+     */
+    workflow: {
+        execute: (workflow: string, input?: Record<string, any> | string) => ITriggerWorkflowAction;
+        dispatch: (workflow: string, input?: Record<string, any> | string) => ITriggerWorkflowAction;
+    };
+    /**
+     * Create an app action
+     */
+    action: {
+        execute: (app: string, action: string, input?: Record<string, any> | string) => ITriggerActionExecuteAction;
+    };
+    /**
+     * Create an agent action
+     */
+    agent: {
+        run: (agent: string, prompt?: string, input?: Record<string, any> | string) => ITriggerAgentAction;
+    };
+    /**
+     * Create a log action
+     */
+    log: {
+        debug: (message: string, data?: Record<string, any> | string) => ITriggerLogAction;
+        info: (message: string, data?: Record<string, any> | string) => ITriggerLogAction;
+        warn: (message: string, data?: Record<string, any> | string) => ITriggerLogAction;
+        error: (message: string, data?: Record<string, any> | string) => ITriggerLogAction;
+    };
+    /**
+     * Create an HTTP action
+     */
+    http: {
+        get: (url: string, options?: Partial<ITriggerHttpAction>) => ITriggerHttpAction;
+        post: (url: string, body?: Record<string, any> | string, options?: Partial<ITriggerHttpAction>) => ITriggerHttpAction;
+        put: (url: string, body?: Record<string, any> | string, options?: Partial<ITriggerHttpAction>) => ITriggerHttpAction;
+        patch: (url: string, body?: Record<string, any> | string, options?: Partial<ITriggerHttpAction>) => ITriggerHttpAction;
+        delete: (url: string, options?: Partial<ITriggerHttpAction>) => ITriggerHttpAction;
+    };
+    /**
+     * Create a custom function action
+     */
+    custom: (handler: (context: ITriggerContext) => Promise<any>) => ITriggerCustomAction;
+    /**
+     * Condition builders
+     */
+    when: {
+        field: (field: string) => {
+            equals: (value: any) => IConditionClause;
+            notEquals: (value: any) => IConditionClause;
+            greaterThan: (value: any) => IConditionClause;
+            lessThan: (value: any) => IConditionClause;
+            in: (values: any[]) => IConditionClause;
+            contains: (value: string) => IConditionClause;
+            isNull: () => IConditionClause;
+            isNotNull: () => IConditionClause;
+            changed: () => IConditionClause;
+            changedTo: (value: any) => IConditionClause;
+            changedFrom: (value: any) => IConditionClause;
+        };
+        and: (...conditions: (IConditionClause | ITriggerCondition)[]) => ITriggerCondition;
+        or: (...conditions: (IConditionClause | ITriggerCondition)[]) => ITriggerCondition;
+        not: (condition: IConditionClause | ITriggerCondition) => ITriggerCondition;
+    };
+};