hikma-engine/dist/api/middleware/error-handling.js

Code Knowledge Graph Indexer - A sophisticated TypeScript-based indexer that transforms Git repositories into multi-dimensional knowledge stores for AI agents

"use strict";
/**
 * @file Enhanced error handling middleware with structured errors and monitoring.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.globalErrorHandler = globalErrorHandler;
exports.asyncErrorHandler = asyncErrorHandler;
exports.handleSearchError = handleSearchError;
exports.handleDatabaseError = handleDatabaseError;
exports.handleCacheError = handleCacheError;
const logger_1 = require("../../utils/logger");
const api_errors_1 = require("../errors/api-errors");
// import { errorMonitoringService } from '../services/error-monitoring'; // Temporarily disabled
const logger = (0, logger_1.getLogger)('ErrorHandlingMiddleware');
/**
 * Global error handler middleware with enhanced monitoring.
 */
function globalErrorHandler(error, req, res, next) {
    const requestId = req.context?.requestId || req.headers['x-request-id'] || 'unknown';
    const startTime = req.context?.startTime || Date.now();
    const processingTime = Date.now() - startTime;
    // Convert to structured API error
    let apiError;
    if (error instanceof api_errors_1.BaseAPIError) {
        apiError = error;
    }
    else {
        apiError = (0, api_errors_1.createAPIError)(error, requestId, {
            method: req.method,
            url: req.url,
            userAgent: req.get('User-Agent'),
            ip: req.ip,
        });
    }
    // Log the error with appropriate level
    apiError.log();
    // Record error for monitoring
    // errorMonitoringService.recordError(apiError); // Temporarily disabled
    // Update performance metrics
    // errorMonitoringService.updatePerformanceMetrics(processingTime, true); // Temporarily disabled
    // Send error response
    const errorResponse = apiError.toJSON();
    if (errorResponse.meta) {
        errorResponse.meta.processingTime = processingTime;
    }
    res.status(apiError.statusCode).json(errorResponse);
}
/**
 * Async error handler wrapper.
 */
function asyncErrorHandler(fn) {
    return (req, res, next) => {
        Promise.resolve(fn(req, res, next)).catch(next);
    };
}
/**
 * Error handler for search operations.
 */
function handleSearchError(error, searchType, query, requestId) {
    if (error instanceof api_errors_1.BaseAPIError) {
        return error;
    }
    if (error instanceof Error) {
        // Map specific search errors
        switch (searchType) {
            case 'semantic':
                return api_errors_1.APIErrors.search.semanticFailed(query, error, requestId);
            case 'structural':
                return api_errors_1.APIErrors.search.structuralFailed(query, error, requestId);
            case 'git':
                return api_errors_1.APIErrors.search.gitFailed(query, error, requestId);
            case 'hybrid':
                return api_errors_1.APIErrors.search.hybridFailed(query, error, requestId);
            case 'comprehensive':
                return api_errors_1.APIErrors.search.comprehensiveFailed(query, error, requestId);
            default:
                return api_errors_1.APIErrors.search.semanticFailed(query, error, requestId);
        }
    }
    return new api_errors_1.InternalServerError('Unknown search error occurred', undefined, requestId);
}
/**
 * Error handler for database operations.
 */
function handleDatabaseError(error, operation, requestId) {
    if (error instanceof api_errors_1.BaseAPIError) {
        return error;
    }
    if (error instanceof Error) {
        // Check for specific database error patterns
        if (error.message.includes('SQLITE_BUSY') || error.message.includes('database is locked')) {
            return api_errors_1.APIErrors.service.databaseUnavailable('SQLite', 'Database is busy', requestId);
        }
        if (error.message.includes('ECONNREFUSED') || error.message.includes('connection refused')) {
            return api_errors_1.APIErrors.service.databaseUnavailable('Database', 'Connection refused', requestId);
        }
        if (error.message.includes('timeout')) {
            return api_errors_1.APIErrors.service.databaseUnavailable('Database', 'Connection timeout', requestId);
        }
        // Generic database error
        return api_errors_1.APIErrors.internal(`Database operation failed: ${operation}`, error, requestId);
    }
    return new api_errors_1.InternalServerError(`Database operation failed: ${operation}`, undefined, requestId);
}
/**
 * Error handler for cache operations.
 */
function handleCacheError(error, operation, requestId) {
    if (error instanceof api_errors_1.BaseAPIError) {
        return error;
    }
    if (error instanceof Error) {
        return api_errors_1.APIErrors.internal(`Cache operation failed: ${operation}`, error, requestId);
    }
    return new api_errors_1.InternalServerError(`Cache operation failed: ${operation}`, undefined, requestId);
}