@emoyly/problem 5.0.8 → 7.0.0

package/src/defaults/4xx.ts

@@ -0,0 +1,149 @@
+// Source: https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+export const statusCodes = {
+    400: {
+        status: 400,
+        title: 'Bad Request',
+        type: '/errors/defaults/4xx/badrequest',
+    },
+    401: {
+        status: 401,
+        title: 'Unauthorized',
+        type: '/errors/defaults/4xx/unauthorized',
+    },
+    402: {
+        status: 402,
+        title: 'Payment Required',
+        type: '/errors/defaults/4xx/paymentrequired',
+    },
+    403: {
+        status: 403,
+        title: 'Forbidden',
+        type: '/errors/defaults/4xx/forbidden',
+    },
+    404: {
+        status: 404,
+        title: 'Not Found',
+        type: '/errors/defaults/4xx/notfound',
+    },
+    406: {
+        status: 406,
+        title: 'Not Acceptable',
+        type: 'errors/defaults/4xx/notacceptable'
+    },
+    405: {
+        status: 405,
+        title: 'Method Not Allowed',
+        type: 'errors/defaults/4xx/methodnotallowed'
+    },
+    407: {
+        status: 407,
+        title: 'Proxy Authentication Required (RFC 7235)',
+        type: 'errors/defaults/4xx/proxyauthenticationrequired'
+    },
+    408: {
+        status: 408,
+        title: 'Request Timeout',
+        type: 'errors/defaults/4xx/requesttimeout'
+    },
+    409: {
+        status: 409,
+        title: 'Conflict',
+        type: 'errors/defaults/4xx/conflict'
+    },
+    410: {
+        status: 410,
+        title: 'Gone',
+        type: 'errors/defaults/4xx/gone'
+    },
+    411: {
+        status: 411,
+        title: 'Length Required',
+        type: 'errors/defaults/4xx/lengthrequired'
+    },
+    412: {
+        status: 412,
+        title: 'Precondition Failed (RFC 7232)',
+        type: 'errors/defaults/4xx/preconditionfailed'
+    },
+    413: {
+        status: 413,
+        title: 'Payload Too Large (RFC 7231)',
+        type: 'errors/defaults/4xx/payloadtoolarge'
+    },
+    414: {
+        status: 414,
+        title: 'URI Too Long (RFC 7231)',
+        type: 'errors/defaults/4xx/uritoolong'
+    },
+    415: {
+        status: 415,
+        title: 'Unsupported Media Type (RFC 7231)',
+        type: 'errors/defaults/4xx/unsupportedmediatype'
+    },
+    416: {
+        status: 416,
+        title: 'Range Not Satisfiable (RFC 7233)',
+        type: 'errors/defaults/4xx/rangenotsatisfiable'
+    },
+    417: {
+        status: 417,
+        title: 'Expectation Failed',
+        type: 'errors/defaults/4xx/expectationfailed'
+    },
+    418: {
+        status: 418,
+        title: 'I\'m a teapot (RFC 2324, RFC 7168)',
+        type: 'errors/defaults/4xx/i\'mateapot'
+    },
+    421: {
+        status: 421,
+        title: 'Misdirected Request (RFC 7540)',
+        type: 'errors/defaults/4xx/misdirectedrequest'
+    },
+    422: {
+        status: 422,
+        title: 'Unprocessable Entity (WebDAV; RFC 4918)',
+        type: 'errors/defaults/4xx/unprocessableentity'
+    },
+    423: {
+        status: 423,
+        title: 'Locked (WebDAV; RFC 4918)',
+        type: 'errors/defaults/4xx/locked'
+    },
+    424: {
+        status: 424,
+        title: 'Failed Dependency (WebDAV; RFC 4918)',
+        type: 'errors/defaults/4xx/faileddependency'
+    },
+    425: {
+        status: 425,
+        title: 'Too Early (RFC 8470)',
+        type: 'errors/defaults/4xx/tooearly'
+    },
+    426: {
+        status: 426,
+        title: 'Upgrade Required',
+        type: 'errors/defaults/4xx/upgraderequired'
+    },
+    428: {
+        status: 428,
+        title: 'Precondition Required (RFC 6585)',
+        type: 'errors/defaults/4xx/preconditionrequired'
+    },
+    429: {
+        status: 429,
+        title: 'Too Many Requests (RFC 6585)',
+        type: 'errors/defaults/4xx/toomanyrequests'
+    },
+    431: {
+        status: 431,
+        title: 'Request Header Fields Too Large (RFC 6585)',
+        type: 'errors/defaults/4xx/requestheaderfieldstoolarge'
+    },
+    451: {
+        status: 451,
+        title: 'Unavailable For Legal Reasons (RFC 7725)',
+        type: 'errors/defaults/4xx/unavailableforlegalreasons'
+    }
+}

package/src/defaults/5xx.ts

@@ -0,0 +1,59 @@
+// Source: https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+export const statusCodes = {
+    500: {
+        status: 500,
+        title: 'Internal Server Error',
+        type: 'errors/defaults/5xx/internalservererror'
+    },
+    501: {
+        status: 501,
+        title: 'Not Implemented',
+        type: 'errors/defaults/5xx/notimplemented'
+    },
+    502: {
+        status: 502,
+        title: 'Bad Gateway',
+        type: 'errors/defaults/5xx/badgateway'
+    },
+    503: {
+        status: 503,
+        title: 'Service Unavailable',
+        type: 'errors/defaults/5xx/serviceunavailable'
+    },
+    504: {
+        status: 504,
+        title: 'Gateway Timeout',
+        type: 'errors/defaults/5xx/gatewaytimeout'
+    },
+    505: {
+        status: 505,
+        title: 'HTTP Version Not Supported',
+        type: 'errors/defaults/5xx/httpversionnotsupported'
+    },
+    506: {
+        status: 506,
+        title: 'Variant Also Negotiates (RFC 2295)',
+        type: 'errors/defaults/5xx/variantalsonegotiates'
+    },
+    507: {
+        status: 507,
+        title: 'Insufficient Storage (WebDAV; RFC 4918)',
+        type: 'errors/defaults/5xx/insufficientstorage'
+    },
+    508: {
+        status: 508,
+        title: 'Loop Detected (WebDAV; RFC 5842)',
+        type: 'errors/defaults/5xx/loopdetected'
+    },
+    511: {
+        status: 511,
+        title: 'Network Authentication Required (RFC 6585)',
+        type: 'errors/defaults/5xx/networkauthenticationrequired'
+    },
+    510: {
+        status: 510,
+        title: 'Not Extended (RFC 2774)',
+        type: 'errors/defaults/5xx/notextended'
+    }
+}

package/src/defaults/aws.ts

@@ -0,0 +1,14 @@
+// Source: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-troubleshooting.html
+
+export const statusCodes = {
+    460: {
+        status: 460,
+        title: 'Client closed connection before idle timeout period elapsed',
+        type: '/errors/defaults/aws/clientclosedbeforetimeout',
+    },
+    463: {
+        status: 463,
+        title: 'X-Forwarded-For contains more than 30 ips',
+        type: '/errors/defaults/aws/toomanyips'
+    }
+}

package/src/defaults/cloudflare.ts

@@ -0,0 +1,50 @@
+// Source: https://support.cloudflare.com/hc/en-us/articles/115003011431
+
+export const statusCodes = {
+    520: {
+        status: 520,
+        title: 'Web Server returned an unknown error',
+        type: '/errors/defaults/cloudflare/unknownerror',
+    },
+    521: {
+        status: 521,
+        title: 'Web server is down',
+        type: '/errors/defaults/cloudflare/webserverdown',
+    },
+    522: {
+        status: 522,
+        title: 'Connection timed out',
+        type: '/errors/defaults/cloudflare/connectiontimeout',
+    },
+    523: {
+        status: 523,
+        title: 'Origin is unreachable',
+        type: '/errors/defaults/cloudflare/originunreachable'
+    },
+    524: {
+        status: 524,
+        title: 'A timeout occurred',
+        type: '/errors/defaults/cloudflare/timeout'
+    },
+    525: {
+        status: 525,
+        title: 'SSL handshake failed',
+        type: '/errors/defaults/cloudflare/sslhandshakefail'
+    },
+    526: {
+        status: 526,
+        title: 'Invalid SSL certificate',
+        type: '/errors/defaults/cloudflare/invalidssl'
+    },
+    // A 527 error indicates an interrupted connection between Cloudflare and your origin's Railgun server (rg-listener)
+    527: {
+        status: 527,
+        title: 'Railgun Listener to origin error',
+        type: '/errors/defaults/cloudflare/railgunoriginerr'
+    },
+    530: {
+        status: 530,
+        title: 'Cloudflare returned 1xxx error',
+        type: '/errors/defaults/cloudflare/1xxx'
+    }
+}

package/src/defaults/iis.ts

@@ -0,0 +1,19 @@
+// Source: https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+export const statusCodes = {
+    440: {
+        status: 440,
+        title: 'Login Time-out',
+        type: '/errors/defaults/iis/logintimeout',
+    },
+    449: {
+        status: 449,
+        title: 'Retry with required information',
+        type: '/errors/defaults/iis/retrywith'
+    },
+    451: {
+        status: 451,
+        title: 'Redirect',
+        type: '/errors/defaults/iis/redirect'
+    }
+}

package/src/defaults/index.ts

@@ -0,0 +1,7 @@
+export { statusCodes as codes4xx } from '../defaults/4xx.js'
+export { statusCodes as codes5xx } from '../defaults/5xx.js'
+export { statusCodes as codesAws } from '../defaults/aws.js'
+export { statusCodes as codesCloudflare } from '../defaults/cloudflare.js'
+export { statusCodes as codesIis } from '../defaults/iis.js'
+export { statusCodes as codesNginx } from '../defaults/nginx.js'
+export { otherErrors } from '../defaults/others.js'

package/src/defaults/nginx.ts

@@ -0,0 +1,34 @@
+// Source: https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+export const statusCodes = {
+    444: {
+        status: 494,
+        title: 'No Response',
+        type: '/errors/defaults/nginx/noresponse',
+    },
+    494: {
+        status: 494,
+        title: 'Request header too large',
+        type: '/errors/defaults/nginx/headertoolarge',
+    },
+    495: {
+        status: 495,
+        title: 'SSL Certificate Error',
+        type: '/errors/defaults/nginx/sslcerterr'
+    },
+    496: {
+        status: 496,
+        title: 'SSL Certificate Required',
+        type: '/errors/defaults/nginx/sslcertrequired'
+    },
+    497: {
+        status: 497,
+        title: 'HTTP Request Sent to HTTPS Port',
+        type: '/errors/defaults/nginx/httpreqtohttpsport'
+    },
+    499: {
+        status: 499,
+        title: 'Client Closed Request',
+        type: '/errors/defaults/nginx/clientclosedreq'
+    }
+}

package/src/defaults/others.ts

@@ -0,0 +1,37 @@
+export const otherErrors = {
+    'unknown': {
+        status: 500,
+        title: 'Unknown error',
+        type: '/errors/defaults/others/unknown',
+    },
+    'corsError': {
+        status: 401,
+        title: 'Request not allowed by CORS policy',
+        type: '/errors/defaults/others/corsdenied',
+    },
+    'problemParseError': {
+        status: 1000,
+        title: 'Could not parse problem details',
+        type: '/errors/defaults/others/problemparseerror',
+    },
+    'problemJsonError': {
+        status: 1000,
+        title: 'Could not parse problem JSON',
+        type: '/errors/defaults/others/problemjsonerror',
+    },
+    'notAnError': {
+        status: 1000,
+        title: 'Not an error',
+        type: '/errors/defaults/others/notanerror',
+    },
+    'networkError': {
+        status: 1000,
+        title: 'Network error',
+        type: '/errors/defaults/others/networkerror'
+    },
+    'inputValidationError': {
+        status: 400,
+        title: 'Input failed validation',
+        type: '/errors/defaults/others/validationerror'
+    }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { Problem } from './problem.js'
+export * as defaults from './defaults/index.js'
+export * from './typings/index.js'
+export * from './util/isProblemArray.js'

package/src/middleware/axios.ts

@@ -0,0 +1,28 @@
+import type { PartialMiddlewareOptions } from '../typings/middleware.js'
+import { MiddlewareBase } from './base.js'
+import axiosParser from '../parsers/axios.js'
+
+type InterceptorArray = [undefined, (error: unknown) => Promise<never>]
+
+export class AxiosMiddleware extends MiddlewareBase {
+    name = 'axios'
+
+    constructor(options?: PartialMiddlewareOptions) {
+        super({
+            'parsers': [axiosParser]
+        }, options)
+    }
+
+    interceptor = async (error: unknown) => {
+        const problems = await this.parse(error)
+
+        this.emit(problems)
+
+        return Promise.reject(problems)
+    }
+
+    /**
+     * @example instance.interceptors.response.use(...middleware.use())
+     */
+    use = (): InterceptorArray => [undefined, this.interceptor]
+}

package/src/middleware/base.ts

@@ -0,0 +1,90 @@
+import { otherErrors } from '../defaults/index.js'
+import { Problem } from '../problem.js'
+import type { ProblemOpts } from '../typings/index.js'
+import type { MiddlewareOptions, PartialMiddlewareOptions, ProblemListener } from '../typings/middleware.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 abstract class MiddlewareBase {
+    options: MiddlewareOptions
+    abstract name: string
+    /**
+     * 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: MiddlewareOptions, options?: PartialMiddlewareOptions) {
+        this.options = { ...defaultOptions, ...options }
+    }
+
+    /**
+     * Call this function when you want to use the middleware function
+     */
+    abstract use(): unknown
+
+    /**
+     * Parse input using parsers
+     */
+    parse = async (input: unknown): Promise<Problem[]> => {
+        const problems: Problem[] = []
+
+        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: ProblemOpts = otherErrors.unknown
+
+    problemListeners: ProblemListener[] = []
+
+    protected emit = (list: Problem[]) => {
+        for (const listener of this.problemListeners) {
+            listener(list)
+        }
+    }
+
+    /**
+     * Listen to problems
+     */
+    onProblem = (listener: ProblemListener) => {
+        this.problemListeners.push(listener)
+    }
+
+    /**
+     * Un-listen to problems
+     */
+    offProblem = (listener: ProblemListener) => {
+        const idx = this.problemListeners.findIndex(val => val === listener)
+
+        if (idx < 0 || isNaN(idx)) return
+
+        this.problemListeners.splice(idx, 1)
+    }
+}

package/src/middleware/express.ts

@@ -0,0 +1,71 @@
+import type { NextFunction, Request, Response } from 'express'
+import type { PartialMiddlewareOptions } from '../typings/middleware.js'
+import { MiddlewareBase } from './base.js'
+import { Problem } from '../problem.js'
+import { codes4xx, otherErrors } from '../defaults/index.js'
+import { defaultInstance } from '../util/defaults.js'
+
+export class ExpressMiddleware extends MiddlewareBase {
+    name = 'express'
+
+    middleware = (error: unknown, req: Request, res: Response, next: NextFunction) => {
+        this.parse(error)
+            .then(problems => {
+                for (const problem of problems) {
+                    if (problem.instance === defaultInstance) {
+                        problem.instance = req.originalUrl
+                    }
+                }
+
+                this.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?: PartialMiddlewareOptions) {
+        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: Request, res: Response, next: NextFunction) => {
+        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/src/parsers/axios.ts

@@ -0,0 +1,61 @@
+import { otherErrors } from '../defaults/others.js'
+import { Problem } from '../problem.js'
+import type { Parser } from '../typings/parser.js'
+import { getProblems } from '../util/getProblems.js'
+import { getHttpError } from '../util/misc.js'
+import type { AxiosError } from 'axios'
+
+function isAxiosError<T = unknown, D = unknown>(payload: unknown): payload is AxiosError<T, D> {
+    return typeof payload === 'object' && payload !== null && 'isAxiosError' in payload && payload.isAxiosError === true
+}
+
+
+const parse: Parser = (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