@energica-city/shared-amplify-utils
Version:
Shared utilities for AWS Amplify projects
127 lines • 17.4 kB
JavaScript
import { logger } from '../../log';
import { extractErrorMessage, createErrorContext } from '../../error';
/**
* Helper to check if error is from our error library.
* This looks for properties that throwError always adds to identify our errors.
*/
function isOurError(error) {
return (error instanceof Error &&
Object.prototype.hasOwnProperty.call(error, '__fromErrorLibrary'));
}
/**
* Helper to safely extract AppSync event properties.
*/
function extractAppSyncEventInfo(event) {
const eventInfo = event.info;
return {
arguments: event.arguments || {},
identity: event.identity || null,
info: eventInfo
? {
fieldName: eventInfo.fieldName,
parentTypeName: eventInfo.parentTypeName,
variables: eventInfo.variables || {},
}
: undefined,
};
}
/**
* Helper to build structured log context for GraphQL errors.
*/
function buildGraphQLLogContext(input, error, defaultContext) {
const eventInfo = extractAppSyncEventInfo(input.event);
const errorWithMiddleware = error;
const context = input.context;
const getMiddlewareChainString = () => {
const chain = errorWithMiddleware.middlewareChain;
if (Array.isArray(chain)) {
return chain.join(' -> ');
}
return undefined;
};
return createErrorContext({
...defaultContext,
// Include any additional properties from the error first
...Object.fromEntries(Object.entries(error).filter(([key]) => !['name', 'message', 'stack'].includes(key))),
requestId: context.awsRequestId || 'unknown',
functionName: context.functionName,
graphql: {
typeName: eventInfo.info?.parentTypeName,
fieldName: eventInfo.info?.fieldName,
arguments: eventInfo.arguments,
},
identity: eventInfo.identity,
failedMiddleware: errorWithMiddleware.middlewareName,
middlewareChain: getMiddlewareChainString(),
});
}
/**
* Creates an error handling middleware for AppSync GraphQL Lambda resolvers.
*
* This middleware catches all errors from downstream middleware or the resolver,
* provides structured logging with GraphQL-specific context, and then re-throws
* the error to let AppSync handle the final response to the client. This ensures
* consistent error logging without interfering with AppSync's native error handling.
*
* It should be the first middleware in the chain to catch all subsequent errors.
*
* @param config - Configuration options for error handling behavior.
* @returns A middleware function that handles and logs errors.
*
* @example
* ```typescript
* const chain = MiddlewareChain.createLambdaChain();
*
* // Add error handling (should be the first middleware)
* chain.use('errorHandler', createGraphQLErrorHandler({
* includeStackTrace: process.env.NODE_ENV === 'development',
* defaultContext: { service: 'inventory-api', version: '1.2.0' }
* }));
*
* // Add other middleware
* chain.use('auth', authMiddleware);
*
* const handler = wrapLambdaHandler(chain, async (event, context) => {
* // No try/catch needed here; errors are handled automatically
* const item = await getItemById(event.arguments.id);
* return item;
* });
* ```
*/
export function createGraphQLErrorHandler(config = {}) {
const { includeStackTrace = process.env.NODE_ENV === 'development', defaultContext = {}, } = config;
return async (input, next) => {
try {
return await next();
}
catch (error) {
let standardError;
let errorMessage;
// Handle non-standard errors by creating a standard error with context
if (!isOurError(error)) {
logger.warn('Non-standard error thrown, wrapping with throwError', {
error,
});
// Create a standard error manually with the same structure as throwError
const wrappedMessage = 'Non-standard error thrown to GraphQL error handler';
standardError = new Error(wrappedMessage);
// Add properties that throwError would have added
standardError.errorType = typeof error;
standardError.originalError = error;
errorMessage = wrappedMessage;
}
else {
standardError = error;
errorMessage = extractErrorMessage(standardError);
}
const logContext = buildGraphQLLogContext(input, standardError, defaultContext);
logger.error(`GraphQL resolver error: ${errorMessage}`, {
...logContext,
...(includeStackTrace && { stack: standardError.stack }),
originalError: standardError.originalError || standardError,
});
throw standardError;
}
};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphQLErrorHandler.js","sourceRoot":"","sources":["../../../middleware/graphql/GraphQLErrorHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import { logger } from '../../log';\nimport { extractErrorMessage, createErrorContext } from '../../error';\nimport type { Middleware, MiddlewareError } from '../middlewareChain';\n\n/**\n * Configuration options for the GraphQL error handling middleware.\n */\nexport interface GraphQLErrorHandlerConfig {\n  /** Whether to include stack traces in logs (default: false in production). */\n  includeStackTrace?: boolean;\n  /** Additional context to include with all logged errors. */\n  defaultContext?: Record<string, unknown>;\n}\n\n/**\n * Helper to check if error is from our error library.\n * This looks for properties that throwError always adds to identify our errors.\n */\nfunction isOurError(\n  error: unknown,\n): error is Error & { [key: string]: unknown } {\n  return (\n    error instanceof Error &&\n    Object.prototype.hasOwnProperty.call(error, '__fromErrorLibrary')\n  );\n}\n\n/**\n * Helper to safely extract AppSync event properties.\n */\nfunction extractAppSyncEventInfo(event: Record<string, unknown>): {\n  arguments: Record<string, unknown>;\n  identity: Record<string, unknown> | null;\n  info:\n    | {\n        fieldName: string | undefined;\n        parentTypeName: string | undefined;\n        variables: Record<string, unknown>;\n      }\n    | undefined;\n} {\n  const eventInfo = event.info as Record<string, unknown> | undefined;\n\n  return {\n    arguments: (event.arguments as Record<string, unknown>) || {},\n    identity: (event.identity as Record<string, unknown> | null) || null,\n    info: eventInfo\n      ? {\n          fieldName: eventInfo.fieldName as string | undefined,\n          parentTypeName: eventInfo.parentTypeName as string | undefined,\n          variables: (eventInfo.variables as Record<string, unknown>) || {},\n        }\n      : undefined,\n  };\n}\n\n/**\n * Helper to build structured log context for GraphQL errors.\n */\nfunction buildGraphQLLogContext(\n  input: {\n    event: Record<string, unknown>;\n    context: Record<string, unknown> | object;\n  },\n  error: Error & { [key: string]: unknown },\n  defaultContext: Record<string, unknown>,\n): Record<string, unknown> {\n  const eventInfo = extractAppSyncEventInfo(input.event);\n  const errorWithMiddleware = error as MiddlewareError;\n  const context = input.context as Record<string, unknown>;\n\n  const getMiddlewareChainString = (): string | undefined => {\n    const chain = errorWithMiddleware.middlewareChain;\n    if (Array.isArray(chain)) {\n      return chain.join(' -> ');\n    }\n    return undefined;\n  };\n\n  return createErrorContext({\n    ...defaultContext,\n    // Include any additional properties from the error first\n    ...Object.fromEntries(\n      Object.entries(error).filter(\n        ([key]) => !['name', 'message', 'stack'].includes(key),\n      ),\n    ),\n    requestId: context.awsRequestId || 'unknown',\n    functionName: context.functionName,\n    graphql: {\n      typeName: eventInfo.info?.parentTypeName,\n      fieldName: eventInfo.info?.fieldName,\n      arguments: eventInfo.arguments,\n    },\n    identity: eventInfo.identity,\n    failedMiddleware: errorWithMiddleware.middlewareName,\n    middlewareChain: getMiddlewareChainString(),\n  });\n}\n\n/**\n * Creates an error handling middleware for AppSync GraphQL Lambda resolvers.\n *\n * This middleware catches all errors from downstream middleware or the resolver,\n * provides structured logging with GraphQL-specific context, and then re-throws\n * the error to let AppSync handle the final response to the client. This ensures\n * consistent error logging without interfering with AppSync's native error handling.\n *\n * It should be the first middleware in the chain to catch all subsequent errors.\n *\n * @param config - Configuration options for error handling behavior.\n * @returns A middleware function that handles and logs errors.\n *\n * @example\n * ```typescript\n * const chain = MiddlewareChain.createLambdaChain();\n *\n * // Add error handling (should be the first middleware)\n * chain.use('errorHandler', createGraphQLErrorHandler({\n *   includeStackTrace: process.env.NODE_ENV === 'development',\n *   defaultContext: { service: 'inventory-api', version: '1.2.0' }\n * }));\n *\n * // Add other middleware\n * chain.use('auth', authMiddleware);\n *\n * const handler = wrapLambdaHandler(chain, async (event, context) => {\n *   // No try/catch needed here; errors are handled automatically\n *   const item = await getItemById(event.arguments.id);\n *   return item;\n * });\n * ```\n */\nexport function createGraphQLErrorHandler<\n  TInput extends {\n    event: Record<string, unknown>;\n    context: Record<string, unknown> | object;\n  },\n  TOutput = unknown,\n>(config: GraphQLErrorHandlerConfig = {}): Middleware<TInput, TOutput> {\n  const {\n    includeStackTrace = process.env.NODE_ENV === 'development',\n    defaultContext = {},\n  } = config;\n\n  return async (input: TInput, next: () => Promise<TOutput>) => {\n    try {\n      return await next();\n    } catch (error) {\n      let standardError: Error & { [key: string]: unknown };\n      let errorMessage: string;\n\n      // Handle non-standard errors by creating a standard error with context\n      if (!isOurError(error)) {\n        logger.warn('Non-standard error thrown, wrapping with throwError', {\n          error,\n        });\n\n        // Create a standard error manually with the same structure as throwError\n        const wrappedMessage =\n          'Non-standard error thrown to GraphQL error handler';\n        standardError = new Error(wrappedMessage) as Error & {\n          [key: string]: unknown;\n        };\n\n        // Add properties that throwError would have added\n        standardError.errorType = typeof error;\n        standardError.originalError = error;\n\n        errorMessage = wrappedMessage;\n      } else {\n        standardError = error;\n        errorMessage = extractErrorMessage(standardError);\n      }\n\n      const logContext = buildGraphQLLogContext(\n        input,\n        standardError,\n        defaultContext,\n      );\n\n      logger.error(`GraphQL resolver error: ${errorMessage}`, {\n        ...logContext,\n        ...(includeStackTrace && { stack: standardError.stack }),\n        originalError: standardError.originalError || standardError,\n      });\n\n      throw standardError;\n    }\n  };\n}\n"]}