@openapi-ts/backend/dist/errors.js

Enables easy implementions of OpenAPI REST APIs in TypeScript with full typings of schemas and operations.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.defaultErrorHandler = exports.HttpError = exports.UnauthorizedError = exports.NotImplementedError = exports.NotFoundError = exports.BadRequestError = exports.ApiError = void 0;
const utils_1 = require("./utils");
function formatOperationName(request) {
    const { method, path } = request;
    return `${method.toUpperCase()} ${path}`;
}
class ApiError extends Error {
    constructor(request, message) {
        super(message);
        this.request = request;
        this.name = this.constructor.name;
    }
}
exports.ApiError = ApiError;
class BadRequestError extends ApiError {
    constructor(request, errors) {
        super(request, `Invalid request: ${utils_1.formatArray(errors, utils_1.formatValidationError)}`);
        this.errors = errors;
    }
}
exports.BadRequestError = BadRequestError;
class NotFoundError extends ApiError {
    constructor(request) {
        super(request, `Unknown operation ${formatOperationName(request)}`);
    }
}
exports.NotFoundError = NotFoundError;
class NotImplementedError extends ApiError {
    constructor(request) {
        super(request, `Operation ${formatOperationName(request)} not implemented`);
    }
}
exports.NotImplementedError = NotImplementedError;
class UnauthorizedError extends ApiError {
    constructor(request, errors) {
        super(request, `Operation ${formatOperationName(request)} not authorized`);
        this.errors = errors;
    }
}
exports.UnauthorizedError = UnauthorizedError;
class HttpError extends Error {
    constructor(message, statusCode, data) {
        super(message);
        this.statusCode = statusCode;
        this.data = data;
    }
}
exports.HttpError = HttpError;
function toHttpError(err, { logger }) {
    if (err instanceof BadRequestError) {
        return new HttpError(`Invalid request`, 400, {
            errors: err.errors.map(({ dataPath, message, keyword, params }) => ({
                message: `${dataPath || 'Request'} ${message}`,
                data: { keyword, dataPath, params }
            }))
        });
    }
    if (err instanceof NotFoundError) {
        return new HttpError(`Resource not found`, 404);
    }
    if (err instanceof NotImplementedError) {
        return new HttpError(`Not implemented`, 501);
    }
    if (err instanceof UnauthorizedError) {
        let statusCode = undefined;
        const errors = err.errors.map(error => {
            const { message = `Authorization scheme failed`, statusCode: subStatusCode, data } = error;
            statusCode = statusCode !== null && statusCode !== void 0 ? statusCode : subStatusCode;
            return { message, data };
        });
        return new HttpError(`Not authorized`, statusCode !== null && statusCode !== void 0 ? statusCode : 401, { errors });
    }
    if (err instanceof HttpError) {
        return err;
    }
    logger.error(`Unhandled internal error: `, err);
    return new HttpError(`Internal error`, 500);
}
const defaultErrorHandler = (req, res, params, err) => {
    const { statusCode = 500, message = 'Unknown error', data } = toHttpError(err, params.api);
    Object.assign(res, { statusCode, body: { message, data } });
};
exports.defaultErrorHandler = defaultErrorHandler;
//# sourceMappingURL=errors.js.map