@emoyly/problem 5.0.7 → 6.0.0

package/esm/middleware/base.js

@@ -0,0 +1,48 @@
+import { otherErrors } from '../defaults/index.js';
+import { Problem } from '../problem.js';
+import { getProblems } from '../util/getProblems.js';
+/**
+ * Middleware collects errors from somewhere, transforms them into something recognizable by a parser, and then passes them to the parsers, and then returns an array of Problems to whatever is using the middleware
+ */
+export class MiddlewareBase {
+    options;
+    /**
+     * When nothing is returned from the parsers, just throw in a default "fallback" Problem object, so that a Problem is still actually returned/emitted
+     */
+    enableFallback = true;
+    constructor(defaultOptions, options) {
+        this.options = { ...defaultOptions, ...options };
+    }
+    /**
+     * Parse input using parsers
+     */
+    parse = async (input) => {
+        const problems = [];
+        const prob = getProblems(input);
+        if (!prob) {
+            for (const parse of this.options.parsers) {
+                const resp = parse(input);
+                if (!resp.length)
+                    continue;
+                problems.push(...resp);
+                break;
+            }
+            if (!problems.length && this.enableFallback) {
+                problems.push(new Problem({
+                    ...this.fallback,
+                    'errorObject': input,
+                    'stack': (typeof input === 'object' && input !== null && 'stack' in input && typeof input.stack === 'string') ? input.stack : undefined
+                }));
+            }
+        }
+        else {
+            problems.push(...prob);
+        }
+        for (const p of problems) {
+            if (!p.middleware)
+                p.middleware = this.name;
+        }
+        return problems;
+    };
+    fallback = otherErrors.unknown;
+}

package/esm/middleware/express.d.ts

@@ -0,0 +1,19 @@
+import type { NextFunction, Request, Response } from 'express';
+import type { PartialMiddlewareOptions } from '../typings/middleware.js';
+import { MiddlewareBase } from './base.js';
+export declare class ExpressMiddleware extends MiddlewareBase {
+    name: string;
+    middleware: (error: unknown, req: Request, res: Response, next: NextFunction) => void;
+    /**
+     * This function applies the middleware to your Express application. Put this at the very end of your middleware/routes.
+     * If you want to also handle 404 errors, check out the notFound middleware function.
+     * @example app.use(middleware.use())
+     */
+    use: () => (error: unknown, req: Request, res: Response, next: NextFunction) => void;
+    constructor(options?: PartialMiddlewareOptions);
+    /**
+     * Put this right before the middleware.use() to catch all 404 errors and respond with a Problem instead of the default Express response
+     * @example app.use(middleware.notFound)
+     */
+    notFound: (req: Request, res: Response, next: NextFunction) => void;
+}

package/esm/middleware/express.js

@@ -0,0 +1,61 @@
+import { MiddlewareBase } from './base.js';
+import { Problem } from '../problem.js';
+import { codes4xx, otherErrors } from '../defaults/index.js';
+import events from '../util/events.js';
+import { defaultInstance } from '../util/defaults.js';
+export class ExpressMiddleware extends MiddlewareBase {
+    name = 'express';
+    middleware = (error, req, res, next) => {
+        this.parse(error)
+            .then(problems => {
+            for (const problem of problems) {
+                if (problem.instance === defaultInstance) {
+                    problem.instance = req.originalUrl;
+                }
+            }
+            events.emit(problems);
+            res
+                .contentType('application/problem+json')
+                .status(problems[0]?.status ?? 500)
+                .json(problems.map(val => val.toObject()));
+        })
+            .catch(err => {
+            res
+                .contentType('application/problem+json')
+                .status(500)
+                .json([
+                new Problem({
+                    ...otherErrors.unknown,
+                    'instance': req.originalUrl,
+                    'status': 500,
+                    'stack': err?.stack,
+                    'errorObject': err,
+                }).toObject()
+            ]);
+            throw err;
+        });
+    };
+    /**
+     * This function applies the middleware to your Express application. Put this at the very end of your middleware/routes.
+     * If you want to also handle 404 errors, check out the notFound middleware function.
+     * @example app.use(middleware.use())
+     */
+    use = () => this.middleware;
+    constructor(options) {
+        super({
+            'parsers': []
+        }, options);
+    }
+    /**
+     * Put this right before the middleware.use() to catch all 404 errors and respond with a Problem instead of the default Express response
+     * @example app.use(middleware.notFound)
+     */
+    notFound = (req, res, next) => {
+        const error = new Problem({
+            ...codes4xx[404],
+            'instance': req.originalUrl,
+            'detail': `No API endpoints exist on ${req.url} for request method ${req.method}`
+        });
+        return next(error);
+    };
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/esm/parsers/axios.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../typings/parser.js';
+declare const parse: Parser;
+export default parse;

package/esm/parsers/axios.js

@@ -0,0 +1,53 @@
+import { otherErrors } from '../defaults/others.js';
+import { Problem } from '../problem.js';
+import { getProblems } from '../util/getProblems.js';
+import { getHttpError } from '../util/misc.js';
+function isAxiosError(payload) {
+    return typeof payload === 'object' && payload !== null && 'isAxiosError' in payload && payload.isAxiosError === true;
+}
+const parse = (input) => {
+    if (typeof input !== 'object' || input == null)
+        return [];
+    if (!isAxiosError(input))
+        return [];
+    const request = input.request;
+    if (input?.response?.data) {
+        const problems = getProblems(input?.response?.data);
+        if (problems?.length)
+            return problems;
+    }
+    if (input?.response) {
+        const opts = getHttpError(input.response.status);
+        if (opts)
+            return [new Problem({
+                    ...opts,
+                    'instance': input?.config?.url,
+                    'stack': input?.stack,
+                    'errorObject': input
+                })];
+    }
+    // TODO: Fix this, this seems bad
+    if (request) {
+        const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+        const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+        if (isBrowser && request instanceof XMLHttpRequest) {
+            return [new Problem({
+                    ...otherErrors.networkError,
+                    'instance': input?.config?.url,
+                    'stack': input?.stack,
+                    'errorObject': input
+                })];
+        }
+        // Probably a ClientRequest
+        if (isNode && 'pipe' in request && 'destroy' in request) {
+            return [new Problem({
+                    ...otherErrors.networkError,
+                    'instance': input?.config?.url,
+                    'stack': input?.stack,
+                    'errorObject': input
+                })];
+        }
+    }
+    return [];
+};
+export default parse;

package/esm/parsers/jsonwebtoken.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../typings/parser.js';
+declare const parse: Parser;
+export default parse;

package/esm/parsers/jsonwebtoken.js

@@ -0,0 +1,94 @@
+import { Problem } from '../problem.js';
+import { JsonWebTokenError, NotBeforeError, TokenExpiredError } from 'jsonwebtoken';
+const errorMap = [
+    {
+        'search': 'invalid token',
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidtoken',
+            'status': 400,
+            'title': 'Invalid JSON Web Token',
+        }
+    },
+    {
+        'search': 'jwt malformed',
+        'result': {
+            'type': '/errors/jsonwebtoken/malformed',
+            'status': 400,
+            'title': 'Malformed JSON Web Token',
+        }
+    },
+    {
+        'search': 'jwt signature is required',
+        'result': {
+            'type': '/errors/jsonwebtoken/signaturerequired',
+            'status': 400,
+            'title': 'JSON Web Token is missing, but required',
+        }
+    },
+    {
+        'search': 'invalid signature',
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidsignature',
+            'status': 400,
+            'title': 'The JSON Web Token signature is invalid',
+        }
+    },
+    {
+        'search': /^(jwt audience invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidaud',
+            'status': 400,
+            'title': 'The JSON Web Token audience is invalid',
+        }
+    },
+    {
+        'search': /^(jwt issuer invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidiss',
+            'status': 400,
+            'title': 'The JSON Web Token issuer is invalid',
+        }
+    },
+    {
+        'search': /^(jwt id invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidid',
+            'status': 400,
+            'title': 'The JSON Web Token id is invalid',
+        }
+    },
+    {
+        'search': /^(jwt subject invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidsubject',
+            'status': 400,
+            'title': 'The JSON Web Token subject is invalid',
+        }
+    }
+];
+const parse = (input) => {
+    if (input instanceof JsonWebTokenError && input.name === 'JsonWebTokenError') {
+        const found = errorMap.find(val => typeof val.search === 'string' ? val.search === input.message : val.search.test(input.message));
+        if (found) {
+            return [new Problem(found.result)];
+        }
+    }
+    else if (input instanceof TokenExpiredError && input.name === 'TokenExpiredError') {
+        return [new Problem({
+                'title': 'The JSON Web Token has expired',
+                'type': '/errors/jsonwebtoken/tokenexpired',
+                'detail': `The JSON Web Token expired at ${input.expiredAt}`,
+                'status': 400,
+            })];
+    }
+    else if (input instanceof NotBeforeError && input.name === 'NotBeforeError') {
+        return [new Problem({
+                'title': 'The JSON Web Token is not valid yet',
+                'type': '/errors/jsonwebtoken/notbefore',
+                'detail': `The JSON Web Token is not valid before ${input.date}`,
+                'status': 400,
+            })];
+    }
+    return [];
+};
+export default parse;

package/esm/parsers/mikroorm.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../typings/parser.js';
+declare const parse: Parser;
+export default parse;

package/esm/parsers/mikroorm.js

@@ -0,0 +1,17 @@
+import { Problem } from '../problem.js';
+import { statusCodes } from '../defaults/4xx.js';
+import { NotFoundError } from '@mikro-orm/core';
+// TODO: Make this less bad
+const parse = (input) => {
+    if (!(input instanceof NotFoundError)) {
+        return [];
+    }
+    return [
+        new Problem({
+            ...statusCodes['404'],
+            'stack': input.stack,
+            'errorObject': input,
+        })
+    ];
+};
+export default parse;

package/esm/parsers/tsoa.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../typings/parser.js';
+declare const parse: Parser;
+export default parse;

package/esm/parsers/tsoa.js

@@ -0,0 +1,21 @@
+import { ValidateError } from 'tsoa';
+import { Problem } from '../problem.js';
+import { otherErrors } from '../defaults/others.js';
+const parse = (input) => {
+    if (!(input instanceof ValidateError)) {
+        return [];
+    }
+    // TODO: Give actual useful responses instead of this shit
+    return [
+        new Problem({
+            ...otherErrors.inputValidationError,
+            'detail': input.message,
+            'status': input.status,
+            'data': {
+                'fields': input.fields,
+            },
+            'stack': input.stack,
+        })
+    ];
+};
+export default parse;

package/esm/problem.d.ts

@@ -0,0 +1,14 @@
+import type { IProblem, ProblemOpts, JsonProblem } from './typings/problem.js';
+export declare class Problem extends Error implements IProblem {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    instance: string;
+    errorObject?: unknown;
+    __problemVersion: string;
+    data: unknown;
+    middleware?: string;
+    constructor({ type, title, status, detail, instance, stack, errorObject, data, middleware }: ProblemOpts);
+    toObject: () => JsonProblem;
+}

package/esm/problem.js

@@ -0,0 +1,56 @@
+import { defaultDetail, defaultInstance, defaultTitle, defaultType } from './util/defaults.js';
+import { version } from './util/version.js';
+export class Problem extends Error {
+    type = defaultType;
+    title = defaultTitle;
+    status = 500;
+    detail = defaultDetail;
+    instance = defaultInstance;
+    errorObject;
+    __problemVersion = version;
+    data = undefined;
+    middleware;
+    constructor({ type, title, status, detail, instance, stack, errorObject, data, middleware }) {
+        super(detail ?? title ?? 'HTTP Problem Details');
+        // TODO: Figure out why i wrote this?
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.type = type;
+        this.title = title;
+        this.status = status;
+        if (detail)
+            this.detail = detail;
+        if (instance)
+            this.instance = instance;
+        if (errorObject)
+            this.errorObject = errorObject;
+        if (middleware)
+            this.middleware = middleware;
+        if (stack) {
+            this.stack = stack;
+        }
+        else if (errorObject && typeof errorObject === 'object' && 'stack' in errorObject && typeof errorObject.stack === 'string') {
+            this.stack = errorObject.stack;
+        }
+        else {
+            if (typeof Error.captureStackTrace === 'function') {
+                Error.captureStackTrace(this, this.constructor);
+            }
+            else {
+                this.stack = new Error(detail ?? title ?? 'HTTP Problem Details').stack;
+            }
+        }
+        if (data)
+            this.data = data;
+    }
+    toObject = () => {
+        return {
+            'type': this.type,
+            'title': this.title,
+            'status': this.status,
+            'detail': this.detail,
+            'instance': this.instance,
+            '__problemVersion': this.__problemVersion,
+            'data': this.data
+        };
+    };
+}