morpheus-node/dist/errors.js

Official Node.js SDK for the Morpheus API Gateway - Connect to the Morpheus-Lumerin AI Marketplace

"use strict";
/**
 * Error handling for Morpheus Node SDK
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.MorpheusStreamError = exports.MorpheusTimeoutError = exports.MorpheusNetworkError = exports.MorpheusValidationError = exports.MorpheusRateLimitError = exports.MorpheusNotFoundError = exports.MorpheusPermissionError = exports.MorpheusAuthenticationError = exports.MorpheusAPIError = exports.MorpheusError = void 0;
exports.isMorpheusError = isMorpheusError;
exports.createErrorFromStatus = createErrorFromStatus;
class MorpheusError extends Error {
    constructor(message, status, code, type, param, details) {
        super(message);
        this.name = 'MorpheusError';
        this.status = status;
        this.code = code;
        this.type = type;
        this.param = param;
        this.details = details;
        // Maintains proper stack trace for where our error was thrown
        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, MorpheusError);
        }
    }
    static fromResponse(response, status) {
        if (response?.error) {
            return new MorpheusError(response.error.message || 'Unknown error', status, response.error.code, response.error.type, response.error.param, response);
        }
        return new MorpheusError(typeof response === 'string' ? response : 'Unknown error', status, undefined, undefined, undefined, response);
    }
}
exports.MorpheusError = MorpheusError;
class MorpheusAPIError extends MorpheusError {
    constructor(message, status, details) {
        super(message, status, 'API_ERROR', undefined, undefined, details);
        this.name = 'MorpheusAPIError';
    }
}
exports.MorpheusAPIError = MorpheusAPIError;
class MorpheusAuthenticationError extends MorpheusError {
    constructor(message = 'Authentication failed') {
        super(message, 401, 'AUTHENTICATION_ERROR');
        this.name = 'MorpheusAuthenticationError';
    }
}
exports.MorpheusAuthenticationError = MorpheusAuthenticationError;
class MorpheusPermissionError extends MorpheusError {
    constructor(message = 'Permission denied') {
        super(message, 403, 'PERMISSION_ERROR');
        this.name = 'MorpheusPermissionError';
    }
}
exports.MorpheusPermissionError = MorpheusPermissionError;
class MorpheusNotFoundError extends MorpheusError {
    constructor(resource) {
        super(`${resource} not found`, 404, 'NOT_FOUND');
        this.name = 'MorpheusNotFoundError';
    }
}
exports.MorpheusNotFoundError = MorpheusNotFoundError;
class MorpheusRateLimitError extends MorpheusError {
    constructor(message = 'Rate limit exceeded', retryAfter) {
        super(message, 429, 'RATE_LIMIT_ERROR');
        this.name = 'MorpheusRateLimitError';
        this.retryAfter = retryAfter;
    }
}
exports.MorpheusRateLimitError = MorpheusRateLimitError;
class MorpheusValidationError extends MorpheusError {
    constructor(message, param) {
        super(message, 400, 'VALIDATION_ERROR', undefined, param);
        this.name = 'MorpheusValidationError';
    }
}
exports.MorpheusValidationError = MorpheusValidationError;
class MorpheusNetworkError extends MorpheusError {
    constructor(message = 'Network error', originalError) {
        super(message, undefined, 'NETWORK_ERROR', undefined, undefined, originalError);
        this.name = 'MorpheusNetworkError';
    }
}
exports.MorpheusNetworkError = MorpheusNetworkError;
class MorpheusTimeoutError extends MorpheusError {
    constructor(message = 'Request timeout') {
        super(message, undefined, 'TIMEOUT_ERROR');
        this.name = 'MorpheusTimeoutError';
    }
}
exports.MorpheusTimeoutError = MorpheusTimeoutError;
class MorpheusStreamError extends MorpheusError {
    constructor(message, details) {
        super(message, undefined, 'STREAM_ERROR', undefined, undefined, details);
        this.name = 'MorpheusStreamError';
    }
}
exports.MorpheusStreamError = MorpheusStreamError;
/**
 * Type guard to check if an error is a MorpheusError
 */
function isMorpheusError(error) {
    return error instanceof MorpheusError;
}
/**
 * Helper to create appropriate error based on status code
 */
function createErrorFromStatus(status, message, details) {
    switch (status) {
        case 401:
            return new MorpheusAuthenticationError(message);
        case 403:
            return new MorpheusPermissionError(message);
        case 404:
            return new MorpheusNotFoundError(message);
        case 429:
            return new MorpheusRateLimitError(message);
        case 400:
            return new MorpheusValidationError(message);
        default:
            if (status >= 500) {
                return new MorpheusAPIError(`Server error: ${message}`, status, details);
            }
            return new MorpheusAPIError(message, status, details);
    }
}