@nekiro/kick-api/lib/errors.js

Efortlessly query kick.com api using easy to use interface with properly typed responses.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.KickNetworkError = exports.KickServerError = exports.KickRateLimitError = exports.KickNotFoundError = exports.KickForbiddenError = exports.KickUnauthorizedError = exports.KickBadRequestError = exports.KickOAuthError = exports.KickApiError = void 0;
exports.createKickError = createKickError;
class KickApiError extends Error {
    constructor(message, status, responseBody, headers, endpoint) {
        super(message);
        this.name = "KickApiError";
        this.status = status;
        this.responseBody = responseBody;
        this.headers = headers;
        this.endpoint = endpoint;
        Object.setPrototypeOf(this, KickApiError.prototype);
    }
    toJSON() {
        return {
            name: this.name,
            message: this.message,
            status: this.status,
            responseBody: this.responseBody,
            headers: this.headers,
            endpoint: this.endpoint,
        };
    }
}
exports.KickApiError = KickApiError;
class KickOAuthError extends KickApiError {
    constructor(message, status, responseBody) {
        super(`OAuth Error: ${message}`, status, responseBody);
        this.name = "KickOAuthError";
        Object.setPrototypeOf(this, KickOAuthError.prototype);
    }
}
exports.KickOAuthError = KickOAuthError;
class KickBadRequestError extends KickApiError {
    constructor(message, responseBody, endpoint) {
        super(`Bad Request: ${message}`, 400, responseBody, undefined, endpoint);
        this.name = "KickBadRequestError";
        Object.setPrototypeOf(this, KickBadRequestError.prototype);
    }
}
exports.KickBadRequestError = KickBadRequestError;
class KickUnauthorizedError extends KickApiError {
    constructor(message = "Unauthorized - Invalid or expired credentials", responseBody, endpoint) {
        super(`Unauthorized: ${message}`, 401, responseBody, undefined, endpoint);
        this.name = "KickUnauthorizedError";
        Object.setPrototypeOf(this, KickUnauthorizedError.prototype);
    }
}
exports.KickUnauthorizedError = KickUnauthorizedError;
class KickForbiddenError extends KickApiError {
    constructor(message = "Forbidden - Access denied", responseBody, endpoint) {
        super(`Forbidden: ${message}`, 403, responseBody, undefined, endpoint);
        this.name = "KickForbiddenError";
        Object.setPrototypeOf(this, KickForbiddenError.prototype);
    }
}
exports.KickForbiddenError = KickForbiddenError;
class KickNotFoundError extends KickApiError {
    constructor(message = "Resource not found", responseBody, endpoint) {
        super(`Not Found: ${message}`, 404, responseBody, undefined, endpoint);
        this.name = "KickNotFoundError";
        Object.setPrototypeOf(this, KickNotFoundError.prototype);
    }
}
exports.KickNotFoundError = KickNotFoundError;
class KickRateLimitError extends KickApiError {
    constructor(message = "Rate limit exceeded", responseBody, retryAfter, endpoint) {
        super(`Rate Limited: ${message}`, 429, responseBody, undefined, endpoint);
        this.name = "KickRateLimitError";
        this.retryAfter = retryAfter;
        Object.setPrototypeOf(this, KickRateLimitError.prototype);
    }
}
exports.KickRateLimitError = KickRateLimitError;
class KickServerError extends KickApiError {
    constructor(message = "Internal server error", status = 500, responseBody, endpoint) {
        super(`Server Error: ${message}`, status, responseBody, undefined, endpoint);
        this.name = "KickServerError";
        Object.setPrototypeOf(this, KickServerError.prototype);
    }
}
exports.KickServerError = KickServerError;
class KickNetworkError extends Error {
    constructor(message, originalError) {
        super(`Network Error: ${message}`);
        this.name = "KickNetworkError";
        this.originalError = originalError;
        Object.setPrototypeOf(this, KickNetworkError.prototype);
    }
}
exports.KickNetworkError = KickNetworkError;
function createKickError(status, statusText, responseBody, headers, endpoint) {
    const message = `${status} ${statusText}`;
    switch (status) {
        case 400:
            return new KickBadRequestError(message, responseBody, endpoint);
        case 401:
            return new KickUnauthorizedError(message, responseBody, endpoint);
        case 403:
            return new KickForbiddenError(message, responseBody, endpoint);
        case 404:
            return new KickNotFoundError(message, responseBody, endpoint);
        case 429:
            const retryAfter = (headers === null || headers === void 0 ? void 0 : headers["retry-after"]) ? parseInt(headers["retry-after"]) : undefined;
            return new KickRateLimitError(message, responseBody, retryAfter, endpoint);
        case 500:
        case 502:
        case 503:
        case 504:
            return new KickServerError(message, status, responseBody, endpoint);
        default:
            return new KickApiError(message, status, responseBody, headers, endpoint);
    }
}