pms-analysis-reports-mcp-server/dist/middleware/index.js

PMS analysis reports server handling maintenance reports, equipment analysis, compliance tracking, and performance metrics with ERP access for data extraction

// Central export for all middleware components
export { ValidationMiddleware } from './validation-middleware.js';
export { SanitizationMiddleware } from './sanitization-middleware.js';
export { ErrorHandler, ErrorCodes } from './error-handler.js';
// Combined middleware wrapper for tool execution
import { ValidationMiddleware } from './validation-middleware.js';
import { SanitizationMiddleware } from './sanitization-middleware.js';
import { ErrorHandler } from './error-handler.js';
import { logger } from '../utils/logger.js';
export class MiddlewareWrapper {
    /**
     * Comprehensive middleware wrapper for tool execution
     * Handles validation, sanitization, error handling, and logging
     */
    static async executeWithMiddleware(toolName, args, operation, options = {}) {
        const { enableValidation = true, enableSanitization = true, enableErrorHandling = true, requestId = ErrorHandler['generateRequestId']() } = options;
        const context = {
            toolName,
            arguments: args,
            requestId,
            timestamp: new Date()
        };
        try {
            // Step 1: Validation
            let processedArgs = args;
            if (enableValidation) {
                const validationResult = ValidationMiddleware.validateToolArguments(toolName, args);
                if (!validationResult.isValid) {
                    throw ErrorHandler.handleValidationError(validationResult.errors, context);
                }
                processedArgs = validationResult.sanitizedArgs || args;
                logger.debug(`Validation passed for tool: ${toolName}`, { requestId });
            }
            // Step 2: Additional Sanitization
            if (enableSanitization) {
                processedArgs = this.deepSanitize(processedArgs);
                logger.debug(`Sanitization completed for tool: ${toolName}`, { requestId });
            }
            // Step 3: Execute Operation
            logger.info(`Executing tool: ${toolName}`, {
                requestId,
                sanitizedArgs: SanitizationMiddleware.sanitizeForLogging(processedArgs)
            });
            const startTime = Date.now();
            const result = await operation(processedArgs);
            const executionTime = Date.now() - startTime;
            logger.info(`Tool execution completed: ${toolName}`, {
                requestId,
                executionTime,
                success: true
            });
            // Step 4: Sanitize Response
            return enableSanitization ? SanitizationMiddleware.sanitizeToolResponse(result) : result;
        }
        catch (error) {
            if (enableErrorHandling) {
                const standardError = ErrorHandler.handleError(error, context);
                // Log error details
                logger.error(`Tool execution failed: ${toolName}`, {
                    requestId,
                    error: standardError,
                    originalError: error.message
                });
                // Return standardized error response
                const errorToThrow = new Error(standardError.message);
                errorToThrow.code = standardError.code;
                errorToThrow.timestamp = standardError.timestamp;
                throw errorToThrow;
            }
            else {
                throw error;
            }
        }
    }
    /**
     * Deep sanitization of nested objects
     */
    static deepSanitize(obj) {
        if (obj === null || obj === undefined) {
            return obj;
        }
        if (typeof obj === 'string') {
            return SanitizationMiddleware.sanitizeString(obj);
        }
        if (typeof obj === 'number') {
            return SanitizationMiddleware.sanitizeNumber(obj);
        }
        if (Array.isArray(obj)) {
            return obj.map(item => this.deepSanitize(item));
        }
        if (typeof obj === 'object') {
            const sanitized = {};
            for (const [key, value] of Object.entries(obj)) {
                sanitized[SanitizationMiddleware.sanitizeString(key, 100)] = this.deepSanitize(value);
            }
            return sanitized;
        }
        return obj;
    }
    /**
     * Middleware for database queries
     */
    static sanitizeDatabaseQuery(query, allowedFields) {
        return SanitizationMiddleware.sanitizeMongoQuery(query, {
            allowedFields,
            maxStringLength: 1000,
            allowObjectIds: true
        });
    }
    /**
     * Middleware for search queries
     */
    static sanitizeSearchQuery(query) {
        return SanitizationMiddleware.sanitizeSearchQuery(query);
    }
    /**
     * Create standardized success response
     */
    static createSuccessResponse(data, metadata) {
        return [{
                type: "success",
                data: SanitizationMiddleware.sanitizeToolResponse(data),
                metadata: metadata ? SanitizationMiddleware.sanitizeToolResponse(metadata) : undefined
            }];
    }
    /**
     * Create standardized error response
     */
    static createErrorResponse(error, toolName, args = {}) {
        return ErrorHandler.createToolErrorResponse(error, toolName, args);
    }
}
//# sourceMappingURL=index.js.map