@emoyly/problem 7.0.6 → 8.0.0

package/src/index.ts

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

package/src/middleware/axios.ts

@@ -1,28 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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 = getProblems(input, this.options.parsers)
-
-        if (!problems || !Array.isArray(problems) || problems.length < 1) {
-            if (this.enableFallback) return [new Problem({
-                ...this.fallback,
-                'errorObject': input,
-                'stack': (typeof input === 'object' && input !== null && 'stack' in input && typeof input.stack === 'string') ? input.stack : undefined,
-                'middleware': this.name
-            })]
-
-            return []
-        }
-
-        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

@@ -1,71 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

package/src/parsers/jsonwebtoken.ts

@@ -1,107 +0,0 @@
-import { Problem } from '../problem.js'
-import type { Parser } from '../typings/parser.js'
-import { JsonWebTokenError, NotBeforeError, TokenExpiredError } from 'jsonwebtoken'
-import type { ProblemOpts } from '../typings/problem.js'
-
-interface ErrorMap {
-    'search': string | RegExp,
-    'result': ProblemOpts,
-}
-
-const errorMap: 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: Parser = (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,
-                'errorObject': input,
-            })]
-        }
-    } 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,
-            'errorObject': input,
-        })]
-    } 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,
-            'errorObject': input,
-        })]
-    }
-}
-
-export default parse

package/src/parsers/mikroorm.ts

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

package/src/parsers/tsoa.ts

@@ -1,26 +0,0 @@
-import { ValidateError } from 'tsoa'
-import { Problem } from '../problem.js'
-import { otherErrors } from '../defaults/others.js'
-import type { Parser } from '../typings/parser.js'
-
-const parse: Parser = (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,
-            'errorObject': input
-        })
-    ]
-}
-
-export default parse

package/src/parsers/zod.ts

@@ -1,23 +0,0 @@
-import { ZodError } from 'zod'
-import type { Parser } from '../typings/parser.js'
-import { Problem } from '../problem.js'
-import { otherErrors } from '../defaults/others.js'
-
-const parse: Parser = (input) => {
-    if (!(input instanceof ZodError)) {
-        return
-    }
-
-    return [new Problem({
-        ...otherErrors.inputValidationError,
-        'detail': `Got ${input.issues.length} validation errors`,
-        'status': 400,
-        'stack': input.stack,
-        'errorObject': input,
-        'data': {
-            'issues': input.issues
-        }
-    })]
-}
-
-export default parse

package/src/problem.ts

@@ -1,56 +0,0 @@
-import type { IProblem, ProblemOpts, JsonProblem } from './typings/problem.js'
-import { defaultDetail, defaultInstance, defaultTitle, defaultType } from './util/defaults.js'
-import { version } from './util/version.js'
-
-export class Problem extends Error implements IProblem {
-    public type = defaultType
-    public title = defaultTitle
-    public status = 500
-    public detail = defaultDetail
-    public instance = defaultInstance
-    public errorObject?: unknown
-    public __problemVersion = version
-    public data: unknown = undefined
-    public middleware?: string
-
-    constructor({ type, title, status, detail, instance, stack, errorObject, data, middleware }: ProblemOpts) {
-        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
-    }
-
-    public toObject = (): JsonProblem => {
-        return {
-            'type': this.type,
-            'title': this.title,
-            'status': this.status,
-            'detail': this.detail,
-            'instance': this.instance,
-            '__problemVersion': this.__problemVersion,
-            'data': this.data
-        }
-    }
-}

package/src/typings/codes.ts

@@ -1,6 +0,0 @@
-import type { ProblemOpts } from './problem.js'
-
-export interface Codes {
-    [key: number]: ProblemOpts | undefined
-    [key: string]: ProblemOpts | undefined
-}

package/src/typings/index.ts

@@ -1,4 +0,0 @@
-export * from './middleware.js'
-export * from './parser.js'
-export * from './problem.js'
-export * from './codes.js'

package/src/typings/middleware.ts

@@ -1,14 +0,0 @@
-import type { Problem } from '../problem.js'
-import type { Parser } from './parser.js'
-
-export interface MiddlewareOptions {
-    /**
-     * A list of parsers to be used by the middleware.
-     * Parsers are run in the order they sit in the array
-     */
-    parsers: Parser[]
-}
-
-export type PartialMiddlewareOptions = Partial<MiddlewareOptions>
-
-export type ProblemListener = (problems: Problem[]) => void

package/src/typings/parser.ts

@@ -1,3 +0,0 @@
-import type { Problem } from '../problem.js'
-
-export type Parser = (input: unknown) => Problem[] | undefined

package/src/typings/problem.ts

@@ -1,27 +0,0 @@
-/**
- * @param {string} type - A URI refrence that identifies the problem type. 
- * @param {string} title - A short, human-readable summary of the problem
- * type.  It SHOULD NOT change from occurrence to occurrence of the problem
- * @param {number} status - The HTTP status code
- * @param {string} detail - A human-readable explanation specific to this
-      occurrence of the problem.
- * @property {string} instance - A URI reference that identifies the specific
-      occurrence of the problem
-**/
-
-export interface IProblem {
-    type: string
-    title: string
-    status: number
-    detail?: string
-    instance?: string
-    stack?: string
-    errorObject?: unknown
-    __problemVersion: string
-    data?: unknown
-    middleware?: string
-}
-
-export type JsonProblem = Omit<IProblem, 'stack' | 'errorObject' | 'middleware'>
-
-export type ProblemOpts = Omit<IProblem, '__problemVersion'>

package/src/util/defaults.ts

@@ -1,4 +0,0 @@
-export const defaultType = '/errors/default/unknown'
-export const defaultTitle = 'Unknown error'
-export const defaultDetail = 'No extended details are available'
-export const defaultInstance = '/unknown'

package/src/util/getProblems.ts

@@ -1,56 +0,0 @@
-import { Problem } from '../problem.js'
-import { Parser } from '../typings/parser.js'
-import type { JsonProblem } from '../typings/problem.js'
-import { isProblemArray } from './problemArray.js'
-import { isCompatibleVersion } from './version.js'
-
-const strings = ['title', 'type', 'instance', 'detail', '__problemVersion'] as const
-export function isJsonProblem(input: unknown): input is JsonProblem {
-    if (input === null) return false
-    if (typeof input !== 'object') return false
-
-    if (!strings.every(val => val in input && typeof input[val as keyof typeof input] === 'string')) return false
-    if (!isCompatibleVersion(('__problemVersion' in input && typeof input['__problemVersion'] === 'string') ? input['__problemVersion'] : '')) return false
-
-    if (!('status' in input) || typeof input.status !== 'number') return false
-
-    return true
-}
-
-export function createFromJson({ title, type, instance, detail, status, data }: JsonProblem): Problem {
-    return new Problem({ title, type, instance, detail, status, data })
-}
-
-/**
- * Get an array of Problems from a given input.
- * Handles existing Problems, arrays of Problems, JSON Problems, JSON Problem arrays and optionally attempts to parse any input with the given parsers.
- * Only returns an array of Problems if it can successfully parse the input.
- */
-export function getProblems(input: unknown, parsers?: Parser[]): Problem[] | undefined {
-    if (typeof input === 'string') {
-        try {
-            const p = JSON.parse(input)
-            input = p
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) { /**/ }
-    }
-
-    if (input instanceof Problem) return [input]
-    if (isProblemArray(input, false)) return input
-
-    if (Array.isArray(input) && input.length > 0 && input.every(val => isJsonProblem(val))) {
-        return input.map(val => createFromJson(val))
-    }
-
-    if (isJsonProblem(input)) {
-        return [createFromJson(input)]
-    }
-
-    if (parsers) {
-        for (const parser of parsers) {
-            const problems = parser(input)
-            if (!problems || !problems.length) continue
-            return problems
-        }
-    }
-}

package/src/util/index.ts

@@ -1,4 +0,0 @@
-export * from './getProblems.js'
-export * from './defaults.js'
-export * from './problemArray.js'
-export * from './misc.js'

package/src/util/misc.ts

@@ -1,21 +0,0 @@
-import * as allCodes from '../defaults/index.js'
-import { ProblemOpts, Codes } from '../typings/index.js'
-
-export function getHttpError(statusCode: number | string): ProblemOpts | undefined {
-    for (const key in allCodes) {
-        // This ensures all codes are written correctly as well, so that's a bonus
-        const codeObject: Codes = allCodes[key as keyof typeof allCodes]
-
-        if (typeof statusCode === 'string') {
-            const conv = Number(statusCode)
-            if (!isNaN(conv)) statusCode = conv
-        }
-
-        const code = codeObject[statusCode]
-
-        if (!code) return
-
-        return code
-    }
-}
-

package/src/util/problemArray.ts

@@ -1,21 +0,0 @@
-import { Problem } from '../problem.js'
-
-/**
- * Checks whether a given object is an array of Problem objects
- * @param input Object to test
- * @param allowEmpty If true or undefined, an empty array is considered a Problem array. If false, an empty array is not considered a Problem array.
- */
-export function isProblemArray(input: unknown, allowEmpty?: boolean): input is Problem[] {
-    if (!Array.isArray(input)) return false
-
-    if (input.length < 1) {
-        if (typeof allowEmpty !== 'boolean') {
-            console.warn(new Error('@emoyly/problem -> isProblemArray: input is an empty array, and therefore is considered a Problem array. If this is not the intended behavior, consider setting the "onlyWhenContent" argument to true.'))
-            return true
-        }
-
-        return allowEmpty
-    }
-
-    return input.every(val => val instanceof Problem)
-}

package/src/util/version.ts

@@ -1,16 +0,0 @@
-export const version = '7.0.6'
-export const major = Number(version.split('.')[0])
-
-export function isCompatibleVersion(inputVersion: string) {
-    // TODO: Remove this
-    if (inputVersion === 'lua-dev') return true
-
-    const parts = inputVersion.split('.')
-    const inputMajor = Number(parts[0])
-
-    if (parts.length !== 3) return false
-    if (isNaN(inputMajor)) return false
-    if (inputMajor !== major) return false
-
-    return true
-}