@revmax/agent-sdk/dist/utils/errors.js

Official Node.js SDK for RevMax - billing, customer management, and usage tracking

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RevMaxInitializationError = exports.RevMaxNotFoundError = exports.RevMaxValidationError = exports.RevMaxRateLimitError = exports.RevMaxAuthenticationError = exports.RevMaxApiError = exports.RevMaxError = void 0;
exports.parseApiError = parseApiError;
/**
 * Base error class for RevMax SDK errors
 */
class RevMaxError extends Error {
    constructor(message, metadata = {}) {
        super(message);
        this.name = 'RevMaxError';
        this.metadata = metadata;
        this.requestId = metadata.requestId;
        // Fix for correct instanceof checks in TypeScript
        Object.setPrototypeOf(this, RevMaxError.prototype);
    }
}
exports.RevMaxError = RevMaxError;
/**
 * Error thrown when there's an API-related issue
 */
class RevMaxApiError extends RevMaxError {
    constructor(message = 'API request failed', statusCode, errorCode, metadata = {}) {
        super(message, metadata);
        this.name = 'RevMaxApiError';
        this.statusCode = statusCode;
        this.errorCode = errorCode;
        // Fix for correct instanceof checks in TypeScript
        Object.setPrototypeOf(this, RevMaxApiError.prototype);
    }
}
exports.RevMaxApiError = RevMaxApiError;
/**
 * Error thrown when authentication fails
 */
class RevMaxAuthenticationError extends RevMaxError {
    constructor(message = 'Authentication failed', metadata = {}) {
        super(message, metadata);
        this.name = 'RevMaxAuthenticationError';
        // Fix for correct instanceof checks in TypeScript
        Object.setPrototypeOf(this, RevMaxAuthenticationError.prototype);
    }
}
exports.RevMaxAuthenticationError = RevMaxAuthenticationError;
/**
 * Error thrown when rate limits are exceeded
 */
class RevMaxRateLimitError extends RevMaxApiError {
    constructor(message = 'Rate limit exceeded', retryAfter, metadata = {}) {
        super(message, 429, 'rate_limit_exceeded', metadata);
        this.name = 'RevMaxRateLimitError';
        this.retryAfter = retryAfter;
        // Fix for correct instanceof checks in TypeScript
        Object.setPrototypeOf(this, RevMaxRateLimitError.prototype);
    }
}
exports.RevMaxRateLimitError = RevMaxRateLimitError;
/**
 * Error thrown when a validation error occurs
 */
class RevMaxValidationError extends RevMaxError {
    constructor(message = 'Validation failed', validationErrors = {}, metadata = {}) {
        super(message, metadata);
        this.name = 'RevMaxValidationError';
        this.validationErrors = validationErrors;
        // Fix for correct instanceof checks in TypeScript
        Object.setPrototypeOf(this, RevMaxValidationError.prototype);
    }
}
exports.RevMaxValidationError = RevMaxValidationError;
/**
 * Error thrown when a resource is not found
 */
class RevMaxNotFoundError extends RevMaxApiError {
    constructor(message = 'Resource not found', statusCode = 404) {
        super(message, statusCode, 'not_found');
        this.name = 'RevMaxNotFoundError';
        // Fix for correct instanceof checks in TypeScript
        Object.setPrototypeOf(this, RevMaxNotFoundError.prototype);
    }
}
exports.RevMaxNotFoundError = RevMaxNotFoundError;
/**
 * Error thrown when initialization fails
 */
class RevMaxInitializationError extends RevMaxError {
    constructor(message = 'Failed to initialize the SDK', metadata = {}) {
        super(message, metadata);
        this.name = 'RevMaxInitializationError';
        // Fix for correct instanceof checks in TypeScript
        Object.setPrototypeOf(this, RevMaxInitializationError.prototype);
    }
}
exports.RevMaxInitializationError = RevMaxInitializationError;
/**
 * Parse API error response into appropriate error object
 * @param error - Error from API request
 * @returns Appropriate RevMaxError instance
 */
function parseApiError(error) {
    // Extract basic information
    const message = error.message || 'Unknown error';
    const statusCode = error.response?.status;
    const responseData = error.response?.data || {};
    const requestId = error.config?.headers?.['X-Request-ID'] || responseData.requestId || 'unknown';
    // Build metadata
    const metadata = {
        requestId,
        url: error.config?.url,
        method: error.config?.method,
        responseData,
    };
    // Handle specific error types
    if (statusCode === 401) {
        return new RevMaxAuthenticationError(responseData.message || 'Authentication failed', metadata);
    }
    if (statusCode === 429) {
        const retryAfter = parseInt(error.response?.headers?.['retry-after'] || '0', 10);
        return new RevMaxRateLimitError(responseData.message || 'Rate limit exceeded', retryAfter, metadata);
    }
    if (statusCode === 422 && responseData.errors) {
        return new RevMaxValidationError(responseData.message || 'Validation failed', responseData.errors, metadata);
    }
    // Default to API error for any API response
    if (statusCode) {
        return new RevMaxApiError(responseData.message || message, statusCode, responseData.code, metadata);
    }
    // Default generic error for network/timeout issues
    return new RevMaxError(message, metadata);
}
//# sourceMappingURL=errors.js.map