@re-shell/cli/dist/utils/plugin-command-middleware.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
import { PluginCommandContext, PluginCommandMiddleware } from './plugin-command-registry';
export declare enum MiddlewareType {
    PRE_VALIDATION = "pre-validation",
    VALIDATION = "validation",
    PRE_EXECUTION = "pre-execution",
    POST_EXECUTION = "post-execution",
    ERROR_HANDLER = "error-handler",
    LOGGER = "logger",
    RATE_LIMITER = "rate-limiter",
    CACHE = "cache",
    TRANSFORM = "transform",
    AUTHORIZATION = "authorization"
}
export interface MiddlewareRegistration {
    id: string;
    pluginName: string;
    type: MiddlewareType;
    priority: number;
    handler: PluginCommandMiddleware;
    options?: MiddlewareOptions;
    isActive: boolean;
    appliesTo?: MiddlewareFilter;
    metadata?: Record<string, any>;
}
export interface MiddlewareOptions {
    timeout?: number;
    skipOnError?: boolean;
    runAsync?: boolean;
    cache?: {
        enabled: boolean;
        ttl: number;
        key?: (args: any, options: any) => string;
    };
    rateLimit?: {
        maxRequests: number;
        windowMs: number;
        skipFailedRequests?: boolean;
    };
}
export interface MiddlewareFilter {
    commands?: string[];
    plugins?: string[];
    categories?: string[];
    patterns?: RegExp[];
    custom?: (context: PluginCommandContext) => boolean;
}
export interface MiddlewareResult {
    success: boolean;
    duration: number;
    error?: Error;
    data?: any;
    modified?: {
        args?: Record<string, any>;
        options?: Record<string, any>;
    };
    skipRemaining?: boolean;
}
export interface BuiltinMiddleware {
    validation: (schema: any) => PluginCommandMiddleware;
    authorization: (permissions: string[]) => PluginCommandMiddleware;
    rateLimit: (options: {
        maxRequests: number;
        windowMs: number;
    }) => PluginCommandMiddleware;
    cache: (options: {
        ttl: number;
        key?: (args: any, options: any) => string;
    }) => PluginCommandMiddleware;
    logger: (options?: {
        level: string;
        format?: string;
    }) => PluginCommandMiddleware;
    transform: (transformers: {
        args?: (args: any) => any;
        options?: (options: any) => any;
    }) => PluginCommandMiddleware;
    errorHandler: (handler: (error: Error, context: PluginCommandContext) => void) => PluginCommandMiddleware;
    timing: () => PluginCommandMiddleware;
}
export declare class MiddlewareChainManager extends EventEmitter {
    private middlewares;
    private typeChains;
    private commandMiddleware;
    private cache;
    private rateLimiters;
    constructor();
    private initializeTypeChains;
    registerMiddleware(pluginName: string, type: MiddlewareType, handler: PluginCommandMiddleware, options?: {
        priority?: number;
        options?: MiddlewareOptions;
        appliesTo?: MiddlewareFilter;
        metadata?: Record<string, any>;
    }): string;
    unregisterMiddleware(id: string): boolean;
    registerCommandMiddleware(commandId: string, middlewareId: string): void;
    executeChain(type: MiddlewareType, args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext): Promise<MiddlewareResult>;
    private executeMiddleware;
    private getMiddlewareChain;
    private appliesTo;
    private updateTypeChain;
    private generateMiddlewareId;
    private getCacheKey;
    private getFromCache;
    private setInCache;
    private getRateLimitKey;
    private checkRateLimit;
    getMiddlewares(): MiddlewareRegistration[];
    getMiddlewaresByType(type: MiddlewareType): MiddlewareRegistration[];
    getMiddlewaresByPlugin(pluginName: string): MiddlewareRegistration[];
    clearCache(): void;
    getStats(): any;
}
export declare const builtinMiddleware: BuiltinMiddleware;
export declare function createMiddlewareChainManager(): MiddlewareChainManager;
export declare function composeMiddleware(...middlewares: PluginCommandMiddleware[]): PluginCommandMiddleware;