@energica-city/shared-amplify-utils/dist/middleware/rest/RestErrorHandler.js

Shared utilities for AWS Amplify projects

import { isRestError, createRestErrorResponse, } from './RestErrors';
import { buildErrorContext, setupStructuredLogging, getErrorMessage, getErrorStack, getRequestId, } from './utils';
import { logger } from '../../log';
/**
 * Checks if an error is a middleware-specific error
 */
function isMiddlewareError(error) {
    return (error instanceof Error &&
        typeof error.middlewareName === 'string');
}
/**
 * Extracts middleware information from middleware errors
 */
function getMiddlewareInfo(error) {
    return {
        name: error.middlewareName || 'unknown',
        index: error.middlewareIndex ?? -1,
        total: error.totalMiddlewares ?? 0,
        chain: error.middlewareChain || [],
    };
}
/**
 * Checks if error was already logged by the error library
 */
function wasErrorAlreadyLogged(error) {
    return (error instanceof Error &&
        '__fromErrorLibrary' in error &&
        error.__fromErrorLibrary ===
            true);
}
/**
 * Handles REST error processing and response creation
 */
function handleRestError(error, context) {
    const { input, requestId, defaultContext, isDev, wasAlreadyLogged } = context;
    if (!wasAlreadyLogged) {
        logger.error('REST error occurred', {
            ...(isDev ? buildErrorContext(input, error, defaultContext) : {}),
            message: error.message,
            code: error.code,
            statusCode: error.statusCode,
            ...(isDev && { stack: getErrorStack(error) }),
        });
    }
    return createRestErrorResponse(error, requestId);
}
/**
 * Handles middleware error processing and response creation
 */
function handleMiddlewareError(error, context) {
    const { input, requestId, defaultContext, isDev, wasAlreadyLogged } = context;
    const middlewareInfo = getMiddlewareInfo(error);
    const message = getErrorMessage(error);
    const stack = getErrorStack(error);
    if (!wasAlreadyLogged) {
        logger.error('Middleware error occurred', {
            ...(isDev ? buildErrorContext(input, null, defaultContext) : {}),
            middlewareName: middlewareInfo.name,
            middlewareIndex: middlewareInfo.index,
            totalMiddlewares: middlewareInfo.total,
            middlewareChain: middlewareInfo.chain,
            originalError: message,
            ...(isDev && { stack }),
        });
    }
    const restError = {
        name: 'MiddlewareError',
        message: `Middleware error in ${middlewareInfo.name}`,
        statusCode: 500,
        code: 'INTERNAL_SERVER_ERROR',
        context: {
            ...buildErrorContext(input, null, defaultContext),
            middlewareName: middlewareInfo.name,
            middlewareIndex: middlewareInfo.index,
            totalMiddlewares: middlewareInfo.total,
            middlewareChain: middlewareInfo.chain,
        },
        originalError: error,
    };
    return createRestErrorResponse(restError, requestId);
}
/**
 * Handles application error processing and response creation
 */
function handleApplicationError(error, context) {
    const { input, requestId, defaultContext, isDev, wasAlreadyLogged } = context;
    const message = getErrorMessage(error);
    const stack = getErrorStack(error);
    if (!wasAlreadyLogged) {
        logger.error('Application error occurred', {
            ...(isDev ? buildErrorContext(input, null, defaultContext) : {}),
            originalError: message,
            errorType: error instanceof Error ? error.constructor.name : 'Unknown',
            ...(isDev && { stack }),
        });
    }
    const restError = {
        name: 'ApplicationError',
        message: message,
        statusCode: 500,
        code: 'INTERNAL_SERVER_ERROR',
        context: {
            ...buildErrorContext(input, null, defaultContext),
        },
        originalError: error,
    };
    return createRestErrorResponse(restError, requestId);
}
/**
 * Creates REST error handler middleware
 *
 * Creates a middleware function that catches and processes all errors
 * in the middleware chain, converting them to appropriate HTTP responses.
 * Uses REST error code mapping for graceful error handling.
 */
export function createRestErrorHandler(config = {}) {
    const { defaultContext = {} } = config;
    const environment = process.env.ENVIRONMENT || 'dev';
    const isDev = environment === 'dev';
    return async (input, next) => {
        setupStructuredLogging(input, true, defaultContext);
        const requestId = getRequestId(input.event, input.context);
        try {
            return await next(input);
        }
        catch (error) {
            const context = {
                input,
                requestId,
                defaultContext,
                isDev,
                wasAlreadyLogged: wasErrorAlreadyLogged(error),
            };
            if (isRestError(error)) {
                return handleRestError(error, context);
            }
            if (isMiddlewareError(error)) {
                return handleMiddlewareError(error, context);
            }
            return handleApplicationError(error, context);
        }
    };
}
//# sourceMappingURL=RestErrorHandler.js.map