@allan1361/iota-big3-sdk-middleware/dist/types/dynamic-loader.d.ts

🏆 A+ Grade Certified Enterprise Middleware Framework - Phase 3 Certified (90/100) with advanced resilience patterns, comprehensive type safety, and production-ready observability

import { EventEmitter } from 'events';
import { RequestHandler } from 'express';
import type { Result } from '@iota-big3/sdk-patterns';
export interface DynamicLoaderConfig {
    middlewarePath?: string;
    configPath?: string;
    watchEnabled?: boolean;
    watchInterval?: number;
    hotReload?: boolean;
    validation?: {
        enabled?: boolean;
        timeout?: number;
        testRequest?: any;
    };
    versioning?: {
        enabled?: boolean;
        maxVersions?: number;
        autoRollback?: boolean;
    };
    security?: {
        sandbox?: boolean;
        allowedModules?: string[];
        checksum?: boolean;
    };
}
export interface MiddlewareDefinition {
    id: string;
    name: string;
    path: string;
    version?: string;
    enabled: boolean;
    priority?: number;
    config?: any;
    dependencies?: string[];
    routes?: string[];
    methods?: string[];
    metadata?: Record<string, any>;
}
export interface LoadedMiddleware {
    id: string;
    definition: MiddlewareDefinition;
    handler: RequestHandler;
    loadedAt: Date;
    version: string;
    checksum?: string;
    instances: number;
    errors: number;
    lastError?: Error;
}
export interface MiddlewareManifest {
    version: string;
    middlewares: MiddlewareDefinition[];
    globalConfig?: any;
    loadOrder?: string[];
}
export interface LoadResult {
    success: boolean;
    middleware?: LoadedMiddleware;
    error?: Error;
    rollbackVersion?: string;
}
export declare class DynamicMiddlewareLoader extends EventEmitter {
    private config;
    private middlewares;
    private versions;
    private manifest?;
    private watcher?;
    private app?;
    constructor(config?: DynamicLoaderConfig);
    initializeAsync(app: any): Promise<void>;
    private loadManifest;
    private loadAllMiddlewares;
    loadMiddleware(definition: MiddlewareDefinition): Promise<Result<LoadResult, Error>>;
    private loadMiddlewareHandler;
    private loadInSandbox;
    private createSafeRequire;
    private validateDefinition;
    private validateMiddlewareAsync;
    private applyMiddleware;
    private wrapHandler;
    private calculateChecksumAsync;
    private storeVersion;
    rollbackAsync(middlewareId: string, targetVersion?: string): Promise<string | null>;
    private startWatching;
    private checkForChangesAsync;
    private reloadManifestAsync;
    private findManifestChanges;
    reloadMiddlewareAsync(middlewareId: string): Promise<Result<LoadResult, Error>>;
    unloadMiddlewareAsync(middlewareId: string): Promise<Result<boolean, Error>>;
    disableMiddlewareAsync(middlewareId: string): Promise<boolean>;
    enableMiddlewareAsync(middlewareId: string): Promise<boolean>;
    getMiddlewares(): Map<string, LoadedMiddleware>;
    getMiddleware(middlewareId: string): LoadedMiddleware | undefined;
    getVersions(middlewareId: string): Map<string, LoadedMiddleware> | undefined;
    getManifest(): MiddlewareManifest | undefined;
    private createMockRequest;
    private createMockResponse;
    stop(): void;
}
export declare function createDynamicLoader(config?: DynamicLoaderConfig): DynamicMiddlewareLoader;
//# sourceMappingURL=dynamic-loader.d.ts.map