view data fixes
This commit is contained in:
475
apps/website/lib/gateways/api/base/BaseApiClient.ts
Normal file
475
apps/website/lib/gateways/api/base/BaseApiClient.ts
Normal file
@@ -0,0 +1,475 @@
|
||||
/**
|
||||
* Base API Client for HTTP operations
|
||||
*
|
||||
* Provides generic HTTP methods with common request/response handling,
|
||||
* error handling, authentication, retry logic, and circuit breaker.
|
||||
*/
|
||||
|
||||
import { Logger } from '../../interfaces/Logger';
|
||||
import { ErrorReporter } from '../../interfaces/ErrorReporter';
|
||||
import { ApiError, ApiErrorType } from './ApiError';
|
||||
import { RetryHandler, CircuitBreakerRegistry, DEFAULT_RETRY_CONFIG } from './RetryHandler';
|
||||
import { ApiConnectionMonitor } from './ApiConnectionMonitor';
|
||||
import { getGlobalApiLogger } from '@/lib/infrastructure/ApiRequestLogger';
|
||||
|
||||
export interface BaseApiClientOptions {
|
||||
timeout?: number;
|
||||
retry?: boolean;
|
||||
retryConfig?: typeof DEFAULT_RETRY_CONFIG;
|
||||
allowUnauthenticated?: boolean;
|
||||
}
|
||||
|
||||
export class BaseApiClient {
|
||||
protected baseUrl: string;
|
||||
private errorReporter: ErrorReporter;
|
||||
private logger: Logger;
|
||||
private retryHandler: RetryHandler;
|
||||
private circuitBreakerRegistry: CircuitBreakerRegistry;
|
||||
private connectionMonitor: ApiConnectionMonitor;
|
||||
private defaultOptions: BaseApiClientOptions;
|
||||
|
||||
constructor(
|
||||
baseUrl: string,
|
||||
errorReporter: ErrorReporter,
|
||||
logger: Logger,
|
||||
options: BaseApiClientOptions = {}
|
||||
) {
|
||||
this.baseUrl = baseUrl;
|
||||
this.errorReporter = errorReporter;
|
||||
this.logger = logger;
|
||||
this.retryHandler = new RetryHandler(options.retryConfig || DEFAULT_RETRY_CONFIG);
|
||||
this.circuitBreakerRegistry = CircuitBreakerRegistry.getInstance();
|
||||
this.connectionMonitor = ApiConnectionMonitor.getInstance();
|
||||
this.defaultOptions = {
|
||||
timeout: options.timeout || 30000,
|
||||
retry: options.retry !== false,
|
||||
retryConfig: options.retryConfig || DEFAULT_RETRY_CONFIG,
|
||||
};
|
||||
|
||||
// Start monitoring connection health
|
||||
// this.connectionMonitor.startMonitoring();
|
||||
}
|
||||
|
||||
/**
|
||||
* Classify HTTP status code into error type
|
||||
*/
|
||||
private classifyError(status: number): ApiErrorType {
|
||||
if (status >= 500) return 'SERVER_ERROR';
|
||||
if (status === 429) return 'RATE_LIMIT_ERROR';
|
||||
if (status === 401 || status === 403) return 'AUTH_ERROR';
|
||||
if (status === 400) return 'VALIDATION_ERROR';
|
||||
if (status === 404) return 'NOT_FOUND';
|
||||
return 'UNKNOWN_ERROR';
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an ApiError from fetch response
|
||||
*/
|
||||
private async createApiError(
|
||||
response: Response,
|
||||
method: string,
|
||||
path: string,
|
||||
retryCount: number = 0
|
||||
): Promise<ApiError> {
|
||||
const status = response.status;
|
||||
const errorType = this.classifyError(status);
|
||||
|
||||
let message = response.statusText;
|
||||
let responseText = '';
|
||||
|
||||
try {
|
||||
responseText = await response.text();
|
||||
if (responseText) {
|
||||
const errorData = JSON.parse(responseText);
|
||||
if (errorData.message) {
|
||||
message = errorData.message;
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Keep default message
|
||||
}
|
||||
|
||||
return new ApiError(
|
||||
message,
|
||||
errorType,
|
||||
{
|
||||
endpoint: path,
|
||||
method,
|
||||
statusCode: status,
|
||||
responseText,
|
||||
timestamp: new Date().toISOString(),
|
||||
retryCount,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an ApiError from network/timeout errors
|
||||
*/
|
||||
private createNetworkError(
|
||||
error: Error,
|
||||
method: string,
|
||||
path: string,
|
||||
retryCount: number = 0
|
||||
): ApiError {
|
||||
let errorType: ApiErrorType = 'NETWORK_ERROR';
|
||||
let message = error.message;
|
||||
|
||||
// More specific error classification
|
||||
if (error.name === 'AbortError') {
|
||||
errorType = 'CANCELED_ERROR';
|
||||
message = 'Request was canceled';
|
||||
} else if (error.name === 'TypeError' && error.message.includes('fetch')) {
|
||||
errorType = 'NETWORK_ERROR';
|
||||
// Check for CORS specifically
|
||||
if (error.message.includes('Failed to fetch') || error.message.includes('fetch failed')) {
|
||||
message = 'Unable to connect to server. Possible CORS or network issue.';
|
||||
}
|
||||
} else if (error.message.includes('timeout') || error.message.includes('timed out')) {
|
||||
errorType = 'TIMEOUT_ERROR';
|
||||
message = 'Request timed out after 30 seconds';
|
||||
} else if (error.message.includes('Failed to fetch') || error.message.includes('NetworkError')) {
|
||||
errorType = 'NETWORK_ERROR';
|
||||
// This could be CORS, network down, or server not responding
|
||||
message = 'Network error: Unable to reach the API server';
|
||||
}
|
||||
|
||||
return new ApiError(
|
||||
message,
|
||||
errorType,
|
||||
{
|
||||
endpoint: path,
|
||||
method,
|
||||
timestamp: new Date().toISOString(),
|
||||
retryCount,
|
||||
// Add helpful context for developers
|
||||
troubleshooting: this.getTroubleshootingContext(error, path),
|
||||
isRetryable: this.isRetryableError(errorType),
|
||||
isConnectivity: errorType === 'NETWORK_ERROR' || errorType === 'TIMEOUT_ERROR',
|
||||
developerHint: this.getDeveloperHint(error, path, method),
|
||||
},
|
||||
error
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if error type is retryable
|
||||
*/
|
||||
private isRetryableError(errorType: ApiErrorType): boolean {
|
||||
const retryableTypes: ApiErrorType[] = [
|
||||
'NETWORK_ERROR',
|
||||
'SERVER_ERROR',
|
||||
'RATE_LIMIT_ERROR',
|
||||
'TIMEOUT_ERROR',
|
||||
];
|
||||
return retryableTypes.includes(errorType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get developer-friendly hint for troubleshooting
|
||||
*/
|
||||
private getDeveloperHint(error: Error, _path: string, _method: string): string {
|
||||
if (error.message.includes('fetch failed') || error.message.includes('Failed to fetch')) {
|
||||
return 'Check if API server is running and CORS is configured correctly';
|
||||
}
|
||||
if (error.message.includes('timeout')) {
|
||||
return 'Request timed out - consider increasing timeout or checking network';
|
||||
}
|
||||
if (error.message.includes('ECONNREFUSED')) {
|
||||
return 'Connection refused - verify API server address and port';
|
||||
}
|
||||
return 'Review network connection and API endpoint configuration';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get troubleshooting context for network errors
|
||||
*/
|
||||
private getTroubleshootingContext(error: Error, _path: string): string {
|
||||
if (typeof window !== 'undefined') {
|
||||
const baseUrl = this.baseUrl;
|
||||
const currentOrigin = window.location.origin;
|
||||
|
||||
// Check if it's likely a CORS issue
|
||||
if (baseUrl && !baseUrl.includes(currentOrigin) && error.message.includes('Failed to fetch')) {
|
||||
return 'CORS issue likely. Check API server CORS configuration.';
|
||||
}
|
||||
|
||||
// Check if API server is same origin
|
||||
if (baseUrl.includes(currentOrigin) || baseUrl.startsWith('/')) {
|
||||
return 'Same-origin request. Check if API server is running.';
|
||||
}
|
||||
}
|
||||
|
||||
return 'Check network connection and API server status.';
|
||||
}
|
||||
|
||||
protected async request<T>(
|
||||
method: string,
|
||||
path: string,
|
||||
data?: object | FormData,
|
||||
options: BaseApiClientOptions & { allowUnauthenticated?: boolean } = {},
|
||||
): Promise<T> {
|
||||
const finalOptions = { ...this.defaultOptions, ...options };
|
||||
const endpoint = `${this.baseUrl}${path}`;
|
||||
|
||||
// Check circuit breaker
|
||||
const circuitBreaker = this.circuitBreakerRegistry.getBreaker(path);
|
||||
if (!circuitBreaker.canExecute()) {
|
||||
const error = new ApiError(
|
||||
'Circuit breaker is open - service temporarily unavailable',
|
||||
'SERVER_ERROR',
|
||||
{
|
||||
endpoint: path,
|
||||
method,
|
||||
timestamp: new Date().toISOString(),
|
||||
}
|
||||
);
|
||||
this.handleError(error);
|
||||
throw error;
|
||||
}
|
||||
|
||||
const executeRequest = async (signal: AbortSignal): Promise<T> => {
|
||||
const isFormData = typeof FormData !== 'undefined' && data instanceof FormData;
|
||||
const headers: Record<string, string> = isFormData
|
||||
? {}
|
||||
: {
|
||||
'Content-Type': 'application/json',
|
||||
};
|
||||
|
||||
// Forward cookies if running on server
|
||||
if (typeof window === 'undefined') {
|
||||
try {
|
||||
const { cookies } = await import('next/headers');
|
||||
const cookieStore = await cookies();
|
||||
const cookieString = cookieStore.toString();
|
||||
if (cookieString) {
|
||||
headers['Cookie'] = cookieString;
|
||||
}
|
||||
} catch (e) {
|
||||
// Not in a request context or next/headers not available
|
||||
}
|
||||
}
|
||||
|
||||
const config: RequestInit = {
|
||||
method,
|
||||
headers,
|
||||
credentials: 'include',
|
||||
signal,
|
||||
};
|
||||
|
||||
if (data) {
|
||||
config.body = isFormData ? data : JSON.stringify(data);
|
||||
}
|
||||
|
||||
const startTime = Date.now();
|
||||
let requestId: string | undefined;
|
||||
|
||||
// Log request start (only in development for maximum transparency)
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
try {
|
||||
const apiLogger = getGlobalApiLogger();
|
||||
const headerObj: Record<string, string> = {};
|
||||
if (typeof headers === 'object') {
|
||||
Object.entries(headers).forEach(([key, value]) => {
|
||||
headerObj[key] = value;
|
||||
});
|
||||
}
|
||||
requestId = apiLogger.logRequest(
|
||||
endpoint,
|
||||
method,
|
||||
headerObj,
|
||||
data
|
||||
);
|
||||
} catch (e) {
|
||||
// Silent fail - logger might not be initialized
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const response = await fetch(endpoint, config);
|
||||
const responseTime = Date.now() - startTime;
|
||||
|
||||
// Record success for monitoring
|
||||
this.connectionMonitor.recordSuccess(responseTime);
|
||||
|
||||
if (!response.ok) {
|
||||
if (
|
||||
finalOptions.allowUnauthenticated &&
|
||||
(response.status === 401 || response.status === 403)
|
||||
) {
|
||||
// For auth probe endpoints, 401/403 is expected
|
||||
return null as T;
|
||||
}
|
||||
|
||||
const error = await this.createApiError(response, method, path);
|
||||
circuitBreaker.recordFailure();
|
||||
this.connectionMonitor.recordFailure(error);
|
||||
this.handleError(error);
|
||||
|
||||
// Log error
|
||||
if (process.env.NODE_ENV === 'development' && requestId) {
|
||||
try {
|
||||
const apiLogger = getGlobalApiLogger();
|
||||
apiLogger.logError(requestId, error, responseTime);
|
||||
} catch (e) {
|
||||
// Silent fail
|
||||
}
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
|
||||
// Record successful circuit breaker call
|
||||
circuitBreaker.recordSuccess();
|
||||
|
||||
const text = await response.text();
|
||||
if (!text) {
|
||||
// Log empty response
|
||||
if (process.env.NODE_ENV === 'development' && requestId) {
|
||||
try {
|
||||
const apiLogger = getGlobalApiLogger();
|
||||
apiLogger.logResponse(requestId, response, null, responseTime);
|
||||
} catch (e) {
|
||||
// Silent fail
|
||||
}
|
||||
}
|
||||
return null as T;
|
||||
}
|
||||
|
||||
const parsedData = JSON.parse(text) as T;
|
||||
|
||||
// Log successful response
|
||||
if (process.env.NODE_ENV === 'development' && requestId) {
|
||||
try {
|
||||
const apiLogger = getGlobalApiLogger();
|
||||
apiLogger.logResponse(requestId, response, parsedData, responseTime);
|
||||
} catch (e) {
|
||||
// Silent fail
|
||||
}
|
||||
}
|
||||
|
||||
return parsedData;
|
||||
|
||||
} catch (error) {
|
||||
const responseTime = Date.now() - startTime;
|
||||
|
||||
if (error instanceof ApiError) {
|
||||
throw error;
|
||||
}
|
||||
|
||||
// Convert to ApiError
|
||||
const apiError = this.createNetworkError(error as Error, method, path);
|
||||
|
||||
circuitBreaker.recordFailure();
|
||||
this.connectionMonitor.recordFailure(apiError);
|
||||
this.handleError(apiError);
|
||||
|
||||
// Log network error
|
||||
if (process.env.NODE_ENV === 'development' && requestId) {
|
||||
try {
|
||||
const apiLogger = getGlobalApiLogger();
|
||||
apiLogger.logError(requestId, apiError, responseTime);
|
||||
} catch (e) {
|
||||
// Silent fail
|
||||
}
|
||||
}
|
||||
|
||||
throw apiError;
|
||||
}
|
||||
};
|
||||
|
||||
// Wrap with retry logic if enabled
|
||||
if (finalOptions.retry) {
|
||||
try {
|
||||
return await this.retryHandler.execute(executeRequest);
|
||||
} catch (error) {
|
||||
// If retry exhausted, throw the final error
|
||||
throw error;
|
||||
}
|
||||
} else {
|
||||
// No retry, just execute with timeout
|
||||
const controller = new AbortController();
|
||||
const timeoutId = setTimeout(() => controller.abort(), finalOptions.timeout);
|
||||
|
||||
try {
|
||||
return await executeRequest(controller.signal);
|
||||
} finally {
|
||||
clearTimeout(timeoutId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle errors - log and report
|
||||
*/
|
||||
private handleError(error: ApiError): void {
|
||||
const severity = error.getSeverity();
|
||||
const message = error.getDeveloperMessage();
|
||||
|
||||
// Enhanced context for better debugging
|
||||
const enhancedContext = {
|
||||
...error.context,
|
||||
severity,
|
||||
isRetryable: error.isRetryable(),
|
||||
isConnectivity: error.isConnectivityIssue(),
|
||||
};
|
||||
|
||||
// Use appropriate log level
|
||||
if (severity === 'error') {
|
||||
this.logger.error(message, error, enhancedContext);
|
||||
} else if (severity === 'warn') {
|
||||
this.logger.warn(message, enhancedContext);
|
||||
} else {
|
||||
this.logger.info(message, enhancedContext);
|
||||
}
|
||||
|
||||
// Report to error tracking
|
||||
this.errorReporter.report(error, enhancedContext);
|
||||
}
|
||||
|
||||
protected get<T>(path: string, options?: BaseApiClientOptions): Promise<T> {
|
||||
return this.request<T>('GET', path, undefined, options);
|
||||
}
|
||||
|
||||
protected post<T>(path: string, data: object, options?: BaseApiClientOptions): Promise<T> {
|
||||
return this.request<T>('POST', path, data, options);
|
||||
}
|
||||
|
||||
protected put<T>(path: string, data: object, options?: BaseApiClientOptions): Promise<T> {
|
||||
return this.request<T>('PUT', path, data, options);
|
||||
}
|
||||
|
||||
protected delete<T>(path: string, options?: BaseApiClientOptions): Promise<T> {
|
||||
return this.request<T>('DELETE', path, undefined, options);
|
||||
}
|
||||
|
||||
protected patch<T>(path: string, data: object, options?: BaseApiClientOptions): Promise<T> {
|
||||
return this.request<T>('PATCH', path, data, options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current connection health status
|
||||
*/
|
||||
getConnectionStatus() {
|
||||
return {
|
||||
status: this.connectionMonitor.getStatus(),
|
||||
health: this.connectionMonitor.getHealth(),
|
||||
isAvailable: this.connectionMonitor.isAvailable(),
|
||||
reliability: this.connectionMonitor.getReliability(),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Force a health check
|
||||
*/
|
||||
async checkHealth() {
|
||||
return this.connectionMonitor.performHealthCheck();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get circuit breaker status for debugging
|
||||
*/
|
||||
getCircuitBreakerStatus() {
|
||||
return this.circuitBreakerRegistry.getStatus();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user