survey-mcp-server/dist/middleware/index.js

Survey management server handling survey creation, response collection, analysis, and reporting with database access for data management

export { ValidationMiddleware, validationMiddleware } from './validation.js';
export { SanitizationMiddleware, sanitizationMiddleware } from './sanitization.js';
export { ErrorHandlingMiddleware, errorHandlingMiddleware, BaseError, ValidationError as MiddlewareValidationError, SanitizationError, DatabaseError, SearchError, ExternalApiError, NotFoundError, ConfigurationError, TimeoutError, ErrorCode } from './error-handling.js';
import { validationMiddleware } from './validation.js';
import { sanitizationMiddleware } from './sanitization.js';
import { errorHandlingMiddleware, ValidationError, SanitizationError } from './error-handling.js';
export class MiddlewareChain {
    constructor() { }
    static getInstance() {
        if (!MiddlewareChain.instance) {
            MiddlewareChain.instance = new MiddlewareChain();
        }
        return MiddlewareChain.instance;
    }
    async processToolCall(toolName, input, operation, options = {}) {
        return errorHandlingMiddleware.wrapAsyncOperation(async () => {
            // Step 1: Validate input
            if (!options.skipValidation) {
                const validationResult = validationMiddleware.validateToolInput(toolName, input);
                if (!validationResult.isValid) {
                    const errorMessage = validationResult.errors.map(e => e.message).join(', ');
                    throw new ValidationError(`Validation failed: ${errorMessage}`, validationResult.errors[0]?.field, validationResult.errors);
                }
                input = validationResult.sanitizedInput || input;
            }
            // Step 2: Sanitize input
            if (!options.skipSanitization) {
                try {
                    input = sanitizationMiddleware.sanitizeInput(input, options.sanitizationOptions);
                }
                catch (error) {
                    throw new SanitizationError(`Input sanitization failed: ${error.message}`);
                }
            }
            // Step 3: Execute operation
            const result = await operation(input);
            // Step 4: Sanitize response (if it's an object)
            if (typeof result === 'object' && result !== null) {
                return sanitizationMiddleware.sanitizeResponse(result);
            }
            return result;
        }, {
            toolName,
            operationType: 'tool_call',
            timeout: options.timeout
        });
    }
    handleError(error, toolName) {
        return errorHandlingMiddleware.handleError(error, toolName);
    }
    async wrapDatabaseOperation(operation, operationName, timeout = 10000) {
        return errorHandlingMiddleware.wrapAsyncOperation(operation, {
            operationType: `database_${operationName}`,
            timeout
        });
    }
    async wrapSearchOperation(operation, operationName, timeout = 5000) {
        return errorHandlingMiddleware.wrapAsyncOperation(operation, {
            operationType: `search_${operationName}`,
            timeout
        });
    }
    async wrapExternalApiOperation(operation, operationName, timeout = 30000) {
        return errorHandlingMiddleware.wrapAsyncOperation(operation, {
            operationType: `external_api_${operationName}`,
            timeout
        });
    }
    validateMongoQuery(query) {
        const validationResult = validationMiddleware.validateMongoQuery(query);
        if (!validationResult.isValid) {
            const errorMessage = validationResult.errors.map(e => e.message).join(', ');
            throw new ValidationError(`MongoDB query validation failed: ${errorMessage}`, 'query', validationResult.errors);
        }
        return sanitizationMiddleware.sanitizeMongoQuery(validationResult.sanitizedInput || query);
    }
}
export const middlewareChain = MiddlewareChain.getInstance();
// Error classes are already exported above in the main export block
//# sourceMappingURL=index.js.map