novel-reader-sdk/dist/errors.js

SDK for Novel Reader API

"use strict";
/**
 * SDK Error Classes
 *
 * Domain-specific error classes for client-side error handling
 * Matches the service's error types for consistency
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.httpStatusMap = exports.ServiceError = exports.RateLimitError = exports.BrowserError = exports.UnsupportedSiteError = exports.ContentNotFoundError = exports.ChapterNotFoundError = exports.ValidationError = exports.TimeoutError = exports.NetworkError = exports.ScrapingServiceError = void 0;
exports.createErrorFromApiResponse = createErrorFromApiResponse;
exports.isScrapingServiceError = isScrapingServiceError;
exports.isErrorOfType = isErrorOfType;
exports.getErrorMessage = getErrorMessage;
class ScrapingServiceError extends Error {
    cause;
    constructor(message, cause) {
        super(message);
        this.cause = cause;
        this.name = this.constructor.name;
    }
}
exports.ScrapingServiceError = ScrapingServiceError;
// ===== Client-Side Errors =====
class NetworkError extends ScrapingServiceError {
    code = 'INTERNAL_SERVER_ERROR';
    type = 'SCRAPING_ERROR';
    constructor(message, cause) {
        super(`Network error: ${message}`, cause);
    }
}
exports.NetworkError = NetworkError;
class TimeoutError extends ScrapingServiceError {
    code = 'TIMEOUT_ERROR';
    type = 'TIMEOUT_ERROR';
    constructor(message, cause) {
        super(`Request timeout: ${message}`, cause);
    }
}
exports.TimeoutError = TimeoutError;
class ValidationError extends ScrapingServiceError {
    code = 'BAD_REQUEST';
    type = 'VALIDATION_ERROR';
    constructor(message, cause) {
        super(`Validation error: ${message}`, cause);
    }
}
exports.ValidationError = ValidationError;
// ===== Service-Side Errors (from API responses) =====
class ChapterNotFoundError extends ScrapingServiceError {
    code = 'NOT_FOUND';
    type = 'CHAPTER_NOT_FOUND';
    constructor(url) {
        super(`Chapter not found at URL: ${url}`);
    }
}
exports.ChapterNotFoundError = ChapterNotFoundError;
class ContentNotFoundError extends ScrapingServiceError {
    code = 'NOT_FOUND';
    type = 'CONTENT_NOT_FOUND';
    constructor(message) {
        super(`Content not found: ${message}`);
    }
}
exports.ContentNotFoundError = ContentNotFoundError;
class UnsupportedSiteError extends ScrapingServiceError {
    code = 'BAD_REQUEST';
    type = 'UNSUPPORTED_SITE';
    constructor(hostname) {
        super(`Unsupported site: ${hostname}`);
    }
}
exports.UnsupportedSiteError = UnsupportedSiteError;
class BrowserError extends ScrapingServiceError {
    code = 'INTERNAL_SERVER_ERROR';
    type = 'BROWSER_ERROR';
    constructor(message) {
        super(`Browser error: ${message}`);
    }
}
exports.BrowserError = BrowserError;
class RateLimitError extends ScrapingServiceError {
    code = 'RATE_LIMIT_EXCEEDED';
    type = 'RATE_LIMIT_ERROR';
    constructor(message) {
        super(`Rate limit exceeded: ${message}`);
    }
}
exports.RateLimitError = RateLimitError;
class ServiceError extends ScrapingServiceError {
    code = 'INTERNAL_SERVER_ERROR';
    type = 'SCRAPING_ERROR';
    constructor(message, cause) {
        super(`Service error: ${message}`, cause);
    }
}
exports.ServiceError = ServiceError;
// ===== Error Mapping and Utilities =====
const errorTypeToClass = {
    SCRAPING_ERROR: ServiceError,
    CHAPTER_NOT_FOUND: ChapterNotFoundError,
    CONTENT_NOT_FOUND: ContentNotFoundError,
    UNSUPPORTED_SITE: UnsupportedSiteError,
    BROWSER_ERROR: BrowserError,
    TIMEOUT_ERROR: TimeoutError,
    VALIDATION_ERROR: ValidationError,
    RATE_LIMIT_ERROR: RateLimitError,
};
/**
 * Creates appropriate error instance from API error response
 */
function createErrorFromApiResponse(apiError) {
    const { code, message } = apiError.error;
    const ErrorClass = errorTypeToClass[code];
    if (ErrorClass) {
        return new ErrorClass(message);
    }
    // Fallback to generic service error
    return new ServiceError(`API Error [${code}]: ${message}`);
}
/**
 * Type guard to check if error is a scraping service error
 */
function isScrapingServiceError(error) {
    return error instanceof ScrapingServiceError;
}
/**
 * Type guard to check if error is a specific error type
 */
function isErrorOfType(error, ErrorClass) {
    return error instanceof ErrorClass;
}
/**
 * Extract error message from various error types
 */
function getErrorMessage(error) {
    if (isScrapingServiceError(error)) {
        return error.message;
    }
    if (error instanceof Error) {
        return error.message;
    }
    if (typeof error === 'string') {
        return error;
    }
    return 'Unknown error occurred';
}
/**
 * HTTP status code mapping for errors
 */
exports.httpStatusMap = {
    INTERNAL_SERVER_ERROR: 500,
    NOT_FOUND: 404,
    BAD_REQUEST: 400,
    UNSUPPORTED_SITE: 400,
    CONTENT_NOT_FOUND: 404,
    BROWSER_ERROR: 500,
    TIMEOUT_ERROR: 408,
    RATE_LIMIT_EXCEEDED: 429,
};
//# sourceMappingURL=errors.js.map