DeepSource MCP Server

/** * @fileoverview Error handlers for specific error types * This module provides utilities for handling different types of errors. */ import { AxiosError } from 'axios'; import { ErrorCategory } from './categories.js'; import { ClassifiedError } from './types.js'; import { createClassifiedError } from './factory.js'; import { createLogger } from '../logging/logger.js'; /** * Error classifier for GraphQL errors * @param error The error to classify * @returns The classified error category * @public */ export function classifyGraphQLError(error: Error): ErrorCategory { const message = error.message.toLowerCase(); // Define error patterns and their corresponding categories const errorPatterns: Record<ErrorCategory, string[]> = { [ErrorCategory.AUTH]: [ 'authentication', 'unauthorized', 'access denied', 'not authorized', 'forbidden', 'token', 'api key', ], [ErrorCategory.RATE_LIMIT]: ['rate limit', 'too many requests', 'throttled'], [ErrorCategory.NETWORK]: ['network', 'connection', 'econnreset', 'econnrefused'], [ErrorCategory.TIMEOUT]: ['timeout', 'timed out', 'etimedout'], [ErrorCategory.SCHEMA]: [ 'cannot query field', 'unknown argument', 'unknown type', 'field not defined', ], [ErrorCategory.NOT_FOUND]: ['not found', 'nonetype', 'does not exist'], [ErrorCategory.SERVER]: ['server error', 'internal error', '500'], [ErrorCategory.CLIENT]: [], [ErrorCategory.FORMAT]: [], [ErrorCategory.OTHER]: [], }; // Check each category's patterns for (const [category, patterns] of Object.entries(errorPatterns)) { if (patterns.some((pattern) => message.includes(pattern))) { return category as ErrorCategory; } } // Default to OTHER return ErrorCategory.OTHER; } /** * Type guard to check if an unknown error is an Error object * @param error The error to check * @returns True if the error is an Error instance * @public */ export function isError(error: unknown): error is Error { return ( error !== null && typeof error === 'object' && 'message' in error && typeof (error as Record<string, unknown>).message === 'string' ); } /** * Type guard to check if an error contains a specific message substring * @param error The error to check * @param substring The substring to search for in the error message * @returns True if the error is an Error with the specified substring * @public */ export function isErrorWithMessage(error: unknown, substring: string): error is Error { return isError(error) && error.message?.includes(substring); } /** * Checks if an error is an Axios error with specific characteristics * @param error The error to check * @param statusCode Optional HTTP status code to match * @param errorCode Optional Axios error code to match * @returns True if the error matches the criteria and is an AxiosError, false otherwise * @public */ export function isAxiosErrorWithCriteria( error: unknown, statusCode?: number, errorCode?: string ): error is AxiosError { // Check if it's an object first if (!error || typeof error !== 'object') { return false; } // Check if it has the axios error shape and matches all criteria const potentialAxiosError = error as Partial<AxiosError>; return ( Boolean(potentialAxiosError.isAxiosError) && (statusCode === undefined || potentialAxiosError.response?.status === statusCode) && (errorCode === undefined || potentialAxiosError.code === errorCode) ); } /** * Extract error messages from GraphQL error response * @param errors Array of GraphQL error objects * @returns Formatted error message string * @public */ export function extractGraphQLErrorMessages(errors: Array<{ message: string }>): string { const errorMessages = errors.map((error) => error.message); return errorMessages.join(', '); } /** * Handle GraphQL-specific errors from Axios responses * @param error The error to check for GraphQL errors * @returns A ClassifiedError if a GraphQL error is found, otherwise null * @public */ export function handleGraphQLSpecificError(error: unknown): ClassifiedError | null { if ( isAxiosErrorWithCriteria(error) && typeof error.response?.data === 'object' && error.response.data && 'errors' in error.response.data ) { const graphqlErrors: Array<{ message: string }> = error.response.data.errors as Array<{ message: string; }>; const errorMessage = extractGraphQLErrorMessages(graphqlErrors); // Create a combined error message const combinedError = new Error(`GraphQL Error: ${errorMessage}`); // Classify the error const category = classifyGraphQLError(combinedError); return createClassifiedError(combinedError.message, category, error, { graphqlErrors }); } return null; } /** * Handle network and connection errors * @param error The error to check * @returns A ClassifiedError if a network error is found, otherwise null * @public */ export function handleNetworkError(error: unknown): ClassifiedError | null { if (!isAxiosErrorWithCriteria(error)) { return null; } // Define a lookup table for error codes const errorCodeHandlers: Record<string, () => ClassifiedError> = { ECONNREFUSED: () => createClassifiedError( 'Connection error: Unable to connect to DeepSource API', ErrorCategory.NETWORK, error ), ETIMEDOUT: () => createClassifiedError( 'Timeout error: DeepSource API request timed out', ErrorCategory.TIMEOUT, error ), }; // Get the error code const errorCode = error.code; // Return the appropriate classified error based on the error code return errorCode ? (errorCodeHandlers[errorCode]?.() ?? null) : null; } /** * Handle HTTP status-specific errors * @param error The error to check * @returns A ClassifiedError if an HTTP status error is found, otherwise null * @public */ export function handleHttpStatusError(error: unknown): ClassifiedError | null { if (!isAxiosErrorWithCriteria(error)) { return null; } const status = error.response?.status; if (!status) { return null; } // Define a lookup table for specific HTTP status codes const statusHandlers: Record<number, () => ClassifiedError> = { 401: () => createClassifiedError( 'Authentication error: Invalid or expired API key', ErrorCategory.AUTH, error ), 429: () => createClassifiedError( 'Rate limit exceeded: Too many requests to DeepSource API', ErrorCategory.RATE_LIMIT, error ), 404: () => createClassifiedError( 'Not found (404): The requested resource was not found', ErrorCategory.NOT_FOUND, error ), 502: () => createClassifiedError( `Bad Gateway (${status}): DeepSource API gateway error`, ErrorCategory.SERVER, error ), 503: () => createClassifiedError( `Service Unavailable (${status}): DeepSource API temporarily unavailable`, ErrorCategory.SERVER, error ), 504: () => createClassifiedError( `Gateway Timeout (${status}): DeepSource API gateway timeout`, ErrorCategory.SERVER, error ), }; // Check for exact status code matches first if (statusHandlers[status]) { return statusHandlers[status](); } // Handle status code ranges if (status >= 500) { return createClassifiedError( `Server error (${status}): DeepSource API server error`, ErrorCategory.SERVER, error ); } if (status >= 400 && status < 500) { return createClassifiedError( `Client error (${status}): ${error.response?.statusText || 'Bad request'}`, ErrorCategory.CLIENT, error ); } return null; } /** * Check if an error is retriable based on its classification * @param error The error to check * @returns True if the error should be retried * @public */ export function isRetriableError(error: unknown): boolean { const retriableCategories = [ ErrorCategory.RATE_LIMIT, ErrorCategory.NETWORK, ErrorCategory.TIMEOUT, ErrorCategory.SERVER, ]; // Check if it's already a classified error if (error && typeof error === 'object' && 'category' in error) { const classifiedError = error as ClassifiedError; return retriableCategories.includes(classifiedError.category); } // Check for specific HTTP status codes if (isAxiosErrorWithCriteria(error)) { const status = (error as AxiosError).response?.status; if (status) { // Retriable status codes const retriableStatusCodes = [429, 502, 503, 504]; if (retriableStatusCodes.includes(status)) { return true; } // Server errors are generally retriable if (status >= 500) { return true; } } // Check for network errors const errorCode = (error as AxiosError).code; if (errorCode) { const retriableErrorCodes = ['ECONNREFUSED', 'ETIMEDOUT', 'ECONNRESET', 'EPIPE']; return retriableErrorCodes.includes(errorCode); } } return false; } /** * Extract Retry-After header from an error response * @param error The error to extract from * @returns The Retry-After header value or undefined * @public */ export function extractRetryAfterHeader(error: unknown): string | undefined { if (!isAxiosErrorWithCriteria(error)) { return undefined; } const axiosError = error as AxiosError; const retryAfter = axiosError.response?.headers?.['retry-after']; if (typeof retryAfter === 'string') { return retryAfter; } return undefined; } /** * Main error handler that processes different error types in sequence * @param error The error to handle * @returns A ClassifiedError appropriate for the error type * @public */ export function handleApiError(error: unknown): ClassifiedError { // Create a logger for error handling const logger = createLogger('ErrorHandler'); logger.debug('Handling API error', { errorType: typeof error, isObject: error !== null && typeof error === 'object', errorKeys: error !== null && typeof error === 'object' ? Object.keys(error) : [], }); // If it's already a classified error, just return it if (error && typeof error === 'object' && 'category' in error) { logger.debug('Error is already classified', { category: (error as ClassifiedError).category, message: (error as ClassifiedError).message, }); return error as ClassifiedError; } // Try handling specific error types in order of specificity logger.debug('Checking for GraphQL-specific errors'); const graphqlError = handleGraphQLSpecificError(error); if (graphqlError) { logger.debug('Identified as GraphQL error', { category: graphqlError.category, message: graphqlError.message, }); return graphqlError; } logger.debug('Checking for network errors'); const networkError = handleNetworkError(error); if (networkError) { logger.debug('Identified as network error', { category: networkError.category, message: networkError.message, }); return networkError; } logger.debug('Checking for HTTP status errors'); const httpError = handleHttpStatusError(error); if (httpError) { logger.debug('Identified as HTTP status error', { category: httpError.category, message: httpError.message, }); return httpError; } // If no specific handler worked, create a generic classified error if (isError(error)) { logger.debug('No specific handler matched, creating generic error', { message: error.message, }); const category = classifyGraphQLError(error); return createClassifiedError(`DeepSource API error: ${error.message}`, category, error); } // Last resort for truly unknown errors logger.debug('Handling completely unknown error type', { error: String(error), }); return createClassifiedError( 'Unknown error occurred while communicating with DeepSource API', ErrorCategory.OTHER, error ); }