@energica-city/shared-amplify-utils
Version:
Shared utilities for AWS Amplify projects
209 lines • 25.8 kB
JavaScript
import { logger } from '../../log';
import { throwError } from '../../error';
import { ERROR_CODES, initializeRestMiddleware, isDevelopment, getErrorMessage, getErrorStack, } from './utils';
/**
* Type guard to check if an error is a middleware error
* @param error - Error of unknown type
* @returns True if error is a MiddlewareError with middlewareName property
*/
function isMiddlewareError(error) {
return (error instanceof Error &&
typeof error.middlewareName === 'string');
}
/**
* Extracts middleware information from a MiddlewareError
* @param error - Middleware error object
* @returns Object containing middleware name, index, total count, and chain
*/
function getMiddlewareInfo(error) {
return {
name: error.middlewareName || 'unknown',
index: error.middlewareIndex ?? -1,
total: error.totalMiddlewares ?? 0,
chain: error.middlewareChain || [],
};
}
/**
* Type guard to check if an error has our custom context structure
* @param error - Error of unknown type
* @returns True if error has a context property of object type
*/
function isOurError(error) {
return (error instanceof Error &&
'context' in error &&
typeof error.context === 'object');
}
/**
* Creates a standardized error response for middleware errors
* @param error - Error object with optional statusCode and context
* @param options - Configuration for error response formatting
* @param options.includeStackTrace - Whether to include stack trace in response
* @param options.includeDetails - Whether to include detailed error information
* @param options.productionErrorMessage - Generic message for production environments
* @returns REST API response object with error details
*/
function createMiddlewareErrorResponse(error, options) {
const { includeStackTrace, includeDetails, productionErrorMessage } = options;
return {
statusCode: error.statusCode || 500,
headers: {
'Content-Type': 'application/json',
'X-Request-ID': error.context?.requestId || 'unknown',
},
body: JSON.stringify({
error: {
code: error.context?.code || 'INTERNAL_SERVER_ERROR',
message: includeDetails ? error.message : productionErrorMessage,
timestamp: error.context?.timestamp || new Date().toISOString(),
requestId: error.context?.requestId || 'unknown',
...(includeStackTrace && { stack: error.stack }),
...(includeDetails && error.context && { context: error.context }),
},
}),
};
}
/**
* Creates REST error handler middleware for standardized error processing
* @param config - Configuration options for error handling behavior
* @returns Middleware function that catches and processes errors
*
* @example
* ```typescript
* chain.use('errorHandler', createRestErrorHandler({
* includeStackTrace: true,
* defaultContext: { service: 'my-api' }
* }));
* ```
*/
export function createRestErrorHandler(config = {}) {
const { includeStackTrace = isDevelopment, defaultContext = {}, forceStructuredLogging = true, } = config;
const includeDetails = isDevelopment;
const productionErrorMessage = 'Internal Server Error';
return async (input, next) => {
const { context: baseContext } = initializeRestMiddleware(input, {
defaultContext,
forceStructuredLogging,
operation: 'errorHandler',
});
try {
return await next(input);
}
catch (error) {
const errorMessage = getErrorMessage(error);
const stack = includeStackTrace ? getErrorStack(error) : undefined;
let enhancedError;
if (!isOurError(error)) {
logger.warn('Non-standard error thrown, wrapping with throwError', {
error: typeof error === 'object' ? error : { message: String(error) },
});
enhancedError = throwError(`Non-standard error thrown to error handler: ${errorMessage}`, error);
const lambdaContext = input.context;
if (lambdaContext && enhancedError.context) {
enhancedError.context.requestId = lambdaContext.awsRequestId;
}
}
else {
enhancedError = error;
}
const errorContext = {};
if (enhancedError && typeof enhancedError === 'object') {
if ('code' in enhancedError && typeof enhancedError.code === 'string') {
errorContext.errorCode = enhancedError.code;
}
if ('statusCode' in enhancedError &&
typeof enhancedError.statusCode === 'number') {
errorContext.statusCode = enhancedError.statusCode;
}
}
const logContext = {
...baseContext,
...errorContext,
};
if (isMiddlewareError(error)) {
const middlewareInfo = getMiddlewareInfo(error);
logger.error(`Middleware error in ${middlewareInfo.name}`, {
...logContext,
middlewareError: middlewareInfo,
stack,
});
}
else {
logger.error(`REST error: ${errorMessage}`, {
...logContext,
stack,
});
}
const errorWithStatusCode = enhancedError;
const errorResponse = createMiddlewareErrorResponse(errorWithStatusCode, {
includeStackTrace,
includeDetails,
productionErrorMessage,
});
return errorResponse;
}
};
}
/**
* HTTP error helper functions for creating standardized error objects
*/
export const HttpErrors = {
badRequest: (message) => ({
statusCode: 400,
code: ERROR_CODES.BAD_REQUEST,
message,
}),
unauthorized: (message) => ({
statusCode: 401,
code: ERROR_CODES.UNAUTHORIZED,
message,
}),
forbidden: (message) => ({
statusCode: 403,
code: ERROR_CODES.FORBIDDEN,
message,
}),
notFound: (message) => ({
statusCode: 404,
code: ERROR_CODES.NOT_FOUND,
message,
}),
methodNotAllowed: (message) => ({
statusCode: 405,
code: ERROR_CODES.METHOD_NOT_ALLOWED,
message,
}),
conflict: (message) => ({
statusCode: 409,
code: ERROR_CODES.CONFLICT,
message,
}),
unprocessableEntity: (message) => ({
statusCode: 422,
code: ERROR_CODES.UNPROCESSABLE_ENTITY,
message,
}),
internalServerError: (message) => ({
statusCode: 500,
code: ERROR_CODES.INTERNAL_SERVER_ERROR,
message,
}),
serviceUnavailable: (message) => ({
statusCode: 503,
code: ERROR_CODES.SERVICE_UNAVAILABLE,
message,
}),
};
/**
* Creates an HTTP error object with status code and error code
* @param statusCode - HTTP status code
* @param code - Error code identifier
* @param message - Error message
* @returns Error object with statusCode and code properties
*/
export function createHttpError(statusCode, code, message) {
const error = new Error(message);
error.statusCode = statusCode;
error.code = code;
return error;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RestErrorHandler.js","sourceRoot":"","sources":["../../../middleware/rest/RestErrorHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import { logger } from '../../log';\nimport { throwError } from '../../error';\nimport {\n  ERROR_CODES,\n  initializeRestMiddleware,\n  isDevelopment,\n  getErrorMessage,\n  getErrorStack,\n} from './utils';\nimport type { Middleware, MiddlewareError } from '../middlewareChain';\nimport type {\n  RestResponse,\n  RestInputWithModels,\n  RestErrorHandlerConfig,\n} from './types';\nimport type { AmplifyModelType } from '../../queries/types';\n\n/**\n * Type guard to check if an error is a middleware error\n * @param error - Error of unknown type\n * @returns True if error is a MiddlewareError with middlewareName property\n */\nfunction isMiddlewareError(error: unknown): error is MiddlewareError {\n  return (\n    error instanceof Error &&\n    typeof (error as MiddlewareError).middlewareName === 'string'\n  );\n}\n\n/**\n * Extracts middleware information from a MiddlewareError\n * @param error - Middleware error object\n * @returns Object containing middleware name, index, total count, and chain\n */\nfunction getMiddlewareInfo(error: MiddlewareError) {\n  return {\n    name: error.middlewareName || 'unknown',\n    index: error.middlewareIndex ?? -1,\n    total: error.totalMiddlewares ?? 0,\n    chain: error.middlewareChain || [],\n  };\n}\n\n/**\n * Type guard to check if an error has our custom context structure\n * @param error - Error of unknown type\n * @returns True if error has a context property of object type\n */\nfunction isOurError(\n  error: unknown,\n): error is Error & { context?: Record<string, unknown> } {\n  return (\n    error instanceof Error &&\n    'context' in error &&\n    typeof (error as { context?: unknown }).context === 'object'\n  );\n}\n\n/**\n * Creates a standardized error response for middleware errors\n * @param error - Error object with optional statusCode and context\n * @param options - Configuration for error response formatting\n * @param options.includeStackTrace - Whether to include stack trace in response\n * @param options.includeDetails - Whether to include detailed error information\n * @param options.productionErrorMessage - Generic message for production environments\n * @returns REST API response object with error details\n */\nfunction createMiddlewareErrorResponse(\n  error: Error & { statusCode?: number; context?: Record<string, unknown> },\n  options: {\n    includeStackTrace: boolean;\n    includeDetails: boolean;\n    productionErrorMessage: string;\n  },\n): RestResponse {\n  const { includeStackTrace, includeDetails, productionErrorMessage } = options;\n\n  return {\n    statusCode: error.statusCode || 500,\n    headers: {\n      'Content-Type': 'application/json',\n      'X-Request-ID': (error.context?.requestId as string) || 'unknown',\n    },\n    body: JSON.stringify({\n      error: {\n        code: (error.context?.code as string) || 'INTERNAL_SERVER_ERROR',\n        message: includeDetails ? error.message : productionErrorMessage,\n        timestamp:\n          (error.context?.timestamp as string) || new Date().toISOString(),\n        requestId: (error.context?.requestId as string) || 'unknown',\n        ...(includeStackTrace && { stack: error.stack }),\n        ...(includeDetails && error.context && { context: error.context }),\n      },\n    }),\n  };\n}\n\n/**\n * Creates REST error handler middleware for standardized error processing\n * @param config - Configuration options for error handling behavior\n * @returns Middleware function that catches and processes errors\n *\n * @example\n * ```typescript\n * chain.use('errorHandler', createRestErrorHandler({\n *   includeStackTrace: true,\n *   defaultContext: { service: 'my-api' }\n * }));\n * ```\n */\nexport function createRestErrorHandler<\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n  TOutput = RestResponse,\n>(\n  config: RestErrorHandlerConfig = {},\n): Middleware<RestInputWithModels<TTypes>, TOutput> {\n  const {\n    includeStackTrace = isDevelopment,\n    defaultContext = {},\n    forceStructuredLogging = true,\n  } = config;\n\n  const includeDetails = isDevelopment;\n  const productionErrorMessage = 'Internal Server Error';\n\n  return async (\n    input: RestInputWithModels<TTypes>,\n    next: (input?: RestInputWithModels<TTypes>) => Promise<TOutput>,\n  ): Promise<TOutput> => {\n    const { context: baseContext } = initializeRestMiddleware(\n      input as RestInputWithModels,\n      {\n        defaultContext,\n        forceStructuredLogging,\n        operation: 'errorHandler',\n      },\n    );\n\n    try {\n      return await next(input);\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n      const stack = includeStackTrace ? getErrorStack(error) : undefined;\n\n      let enhancedError: Error & { context?: Record<string, unknown> };\n\n      if (!isOurError(error)) {\n        logger.warn('Non-standard error thrown, wrapping with throwError', {\n          error: typeof error === 'object' ? error : { message: String(error) },\n        });\n\n        enhancedError = throwError(\n          `Non-standard error thrown to error handler: ${errorMessage}`,\n          error,\n        ) as Error & { context?: Record<string, unknown> };\n\n        const lambdaContext = input.context;\n        if (lambdaContext && enhancedError.context) {\n          enhancedError.context.requestId = lambdaContext.awsRequestId;\n        }\n      } else {\n        enhancedError = error;\n      }\n\n      const errorContext: Record<string, unknown> = {};\n      if (enhancedError && typeof enhancedError === 'object') {\n        if ('code' in enhancedError && typeof enhancedError.code === 'string') {\n          errorContext.errorCode = enhancedError.code;\n        }\n        if (\n          'statusCode' in enhancedError &&\n          typeof enhancedError.statusCode === 'number'\n        ) {\n          errorContext.statusCode = enhancedError.statusCode;\n        }\n      }\n\n      const logContext = {\n        ...baseContext,\n        ...errorContext,\n      };\n\n      if (isMiddlewareError(error)) {\n        const middlewareInfo = getMiddlewareInfo(error);\n        logger.error(`Middleware error in ${middlewareInfo.name}`, {\n          ...logContext,\n          middlewareError: middlewareInfo,\n          stack,\n        });\n      } else {\n        logger.error(`REST error: ${errorMessage}`, {\n          ...logContext,\n          stack,\n        });\n      }\n\n      const errorWithStatusCode = enhancedError as Error & {\n        statusCode?: number;\n        context?: Record<string, unknown>;\n      };\n\n      const errorResponse = createMiddlewareErrorResponse(errorWithStatusCode, {\n        includeStackTrace,\n        includeDetails,\n        productionErrorMessage,\n      });\n\n      return errorResponse as TOutput;\n    }\n  };\n}\n\n/**\n * HTTP error helper functions for creating standardized error objects\n */\nexport const HttpErrors = {\n  badRequest: (message: string) => ({\n    statusCode: 400,\n    code: ERROR_CODES.BAD_REQUEST,\n    message,\n  }),\n  unauthorized: (message: string) => ({\n    statusCode: 401,\n    code: ERROR_CODES.UNAUTHORIZED,\n    message,\n  }),\n  forbidden: (message: string) => ({\n    statusCode: 403,\n    code: ERROR_CODES.FORBIDDEN,\n    message,\n  }),\n  notFound: (message: string) => ({\n    statusCode: 404,\n    code: ERROR_CODES.NOT_FOUND,\n    message,\n  }),\n  methodNotAllowed: (message: string) => ({\n    statusCode: 405,\n    code: ERROR_CODES.METHOD_NOT_ALLOWED,\n    message,\n  }),\n  conflict: (message: string) => ({\n    statusCode: 409,\n    code: ERROR_CODES.CONFLICT,\n    message,\n  }),\n  unprocessableEntity: (message: string) => ({\n    statusCode: 422,\n    code: ERROR_CODES.UNPROCESSABLE_ENTITY,\n    message,\n  }),\n  internalServerError: (message: string) => ({\n    statusCode: 500,\n    code: ERROR_CODES.INTERNAL_SERVER_ERROR,\n    message,\n  }),\n  serviceUnavailable: (message: string) => ({\n    statusCode: 503,\n    code: ERROR_CODES.SERVICE_UNAVAILABLE,\n    message,\n  }),\n} as const;\n\n/**\n * Creates an HTTP error object with status code and error code\n * @param statusCode - HTTP status code\n * @param code - Error code identifier\n * @param message - Error message\n * @returns Error object with statusCode and code properties\n */\nexport function createHttpError(\n  statusCode: number,\n  code: string,\n  message: string,\n) {\n  const error = new Error(message) as Error & {\n    statusCode: number;\n    code: string;\n  };\n  error.statusCode = statusCode;\n  error.code = code;\n  return error;\n}\n"]}