n8n-nodes-semble/dist/core/MiddlewarePipeline.d.ts

n8n community node for Semble practice management system - automate bookings, patients, and product/service catalog management

/**
 * @fileoverview MiddlewarePipeline.ts
 * @description Request/response processing pipeline with middleware chain execution for validation, permission checking, and error transformation
 * @author Mike Hatcher
 * @website https://progenious.com
 * @namespace N8nNodesSemble.Core.MiddlewarePipeline
 * @since 2.0.0
 */
import { IExecuteFunctions } from 'n8n-workflow';
import { SembleError } from './SembleError';
import { EventSystem, BaseEvent } from './EventSystem';
/**
 * Middleware pipeline event interfaces
 */
export interface MiddlewareRegisteredEvent extends BaseEvent {
    name: string;
    priority: number;
    enabled: boolean;
}
export interface MiddlewareUnregisteredEvent extends BaseEvent {
    name: string;
}
export interface MiddlewareToggledEvent extends BaseEvent {
    name: string;
    enabled: boolean;
}
export interface MiddlewareClearedEvent extends BaseEvent {
    count: number;
}
export interface PipelineStartedEvent extends BaseEvent {
    middlewareCount: number;
    resource: string;
    action: string;
}
export interface PipelineCompletedEvent extends BaseEvent {
    executionTime: number;
    middlewareCount: number;
    successfulMiddleware: number;
    resource: string;
    action: string;
}
export interface PipelineFailedEvent extends BaseEvent {
    error: string;
    executionTime: number;
    resource: string;
    action: string;
}
export interface PipelineMiddlewareErrorEvent extends BaseEvent {
    middlewareName: string;
    error: string;
    continuing: boolean;
}
/**
 * Pipeline context that flows through middleware chain
 */
export interface PipelineContext {
    /** Execution context from n8n */
    executeFunctions: IExecuteFunctions;
    /** Current request data */
    request: {
        /** GraphQL query string */
        query: string;
        /** Query variables */
        variables: Record<string, any>;
        /** Request metadata */
        metadata: {
            resource: string;
            action: string;
            itemIndex?: number;
            [key: string]: any;
        };
    };
    /** Response data (populated during pipeline execution) */
    response?: {
        /** Raw API response */
        data: any;
        /** Processed response data */
        processedData?: any;
        /** Response metadata */
        metadata?: Record<string, any>;
    };
    /** Shared context between middleware */
    shared: Record<string, any>;
    /** Error information if pipeline fails */
    error?: SembleError;
}
/**
 * Middleware function signature
 */
export type MiddlewareFunction = (context: PipelineContext, next: () => Promise<void>) => Promise<void>;
/**
 * Middleware registration information
 */
export interface MiddlewareRegistration {
    /** Unique middleware name */
    name: string;
    /** Middleware function */
    middleware: MiddlewareFunction;
    /** Execution priority (lower = earlier) */
    priority: number;
    /** Whether middleware is enabled */
    enabled: boolean;
}
/**
 * Pipeline execution options
 */
export interface PipelineOptions {
    /** Whether to continue on middleware errors */
    continueOnError?: boolean;
    /** Maximum execution time in milliseconds */
    timeout?: number;
    /** Whether to emit pipeline events */
    emitEvents?: boolean;
}
/**
 * Pipeline execution result
 */
export interface PipelineResult {
    /** Whether pipeline completed successfully */
    success: boolean;
    /** Final pipeline context */
    context: PipelineContext;
    /** Execution time in milliseconds */
    executionTime: number;
    /** Middleware execution trace */
    trace: Array<{
        name: string;
        startTime: number;
        endTime: number;
        success: boolean;
        error?: string;
    }>;
}
/**
 * Request/response processing pipeline with middleware chain
 * Provides extensible processing for API requests and responses
 */
export declare class MiddlewarePipeline {
    private middlewares;
    private eventSystem?;
    constructor(eventSystem?: EventSystem);
    /**
     * Register a middleware function
     */
    register(name: string, middleware: MiddlewareFunction, priority?: number, enabled?: boolean): void;
    /**
     * Unregister a middleware
     */
    unregister(name: string): boolean;
    /**
     * Enable or disable a middleware
     */
    setEnabled(name: string, enabled: boolean): boolean;
    /**
     * Get all registered middleware
     */
    getMiddlewares(): MiddlewareRegistration[];
    /**
     * Get enabled middleware in execution order
     */
    getEnabledMiddlewares(): MiddlewareRegistration[];
    /**
     * Clear all registered middleware
     */
    clear(): void;
    /**
     * Execute the middleware pipeline
     */
    execute(context: PipelineContext, options?: PipelineOptions): Promise<PipelineResult>;
    /**
     * Create a new pipeline with pre-configured middleware
     */
    static createWithDefaults(eventSystem?: EventSystem): MiddlewarePipeline;
    /**
     * Built-in request validation middleware
     */
    static requestValidationMiddleware: MiddlewareFunction;
    /**
     * Built-in permission check middleware
     */
    static permissionCheckMiddleware: MiddlewareFunction;
    /**
     * Built-in API execution middleware
     */
    static apiExecutionMiddleware: MiddlewareFunction;
    /**
     * Built-in response processing middleware
     */
    static responseProcessingMiddleware: MiddlewareFunction;
    /**
     * Built-in error mapping middleware
     */
    static errorMappingMiddleware: MiddlewareFunction;
}
/**
 * Utility functions for pipeline management
 */
export declare class MiddlewarePipelineUtils {
    /**
     * Create a basic pipeline context
     */
    static createContext(executeFunctions: IExecuteFunctions, query: string, variables: Record<string, any>, resource: string, action: string, itemIndex?: number): PipelineContext;
    /**
     * Create a pipeline with common Semble middleware
     */
    static createSemblePipeline(eventSystem?: EventSystem): MiddlewarePipeline;
    /**
     * Execute a simple request through the pipeline
     */
    static executeRequest(pipeline: MiddlewarePipeline, executeFunctions: IExecuteFunctions, query: string, variables: Record<string, any>, resource: string, action: string, options?: PipelineOptions): Promise<PipelineResult>;
}