@emoyly/problem 8.0.5 → 9.0.0

package/{cjs/parsers/jsonwebtoken.js → src/parsers/jsonwebtoken.ts}

@@ -1,8 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const problem_js_1 = require("../problem.js");
-const jsonwebtoken_1 = require("jsonwebtoken");
-const errorMap = [
+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': {
@@ -67,37 +73,38 @@ const errorMap = [
             'title': 'The JSON Web Token subject is invalid',
         }
     }
-];
-const parse = (input) => {
-    if (input instanceof jsonwebtoken_1.JsonWebTokenError && input.name === 'JsonWebTokenError') {
-        const found = errorMap.find(val => typeof val.search === 'string' ? val.search === input.message : val.search.test(input.message));
+]
+
+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_js_1.Problem({
-                    ...found.result,
-                    'errorObject': input,
-                    'source': 'parser:jsonwebtoken'
-                })];
-        }
-    }
-    else if (input instanceof jsonwebtoken_1.TokenExpiredError && input.name === 'TokenExpiredError') {
-        return [new problem_js_1.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,
-                'source': 'parser:jsonwebtoken'
-            })];
-    }
-    else if (input instanceof jsonwebtoken_1.NotBeforeError && input.name === 'NotBeforeError') {
-        return [new problem_js_1.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 [new Problem({
+                ...found.result,
                 'errorObject': input,
                 'source': 'parser:jsonwebtoken'
-            })];
+            })]
+        }
+    } 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,
+            'source': 'parser:jsonwebtoken'
+        })]
+    } 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,
+            'source': 'parser:jsonwebtoken'
+        })]
     }
-};
-exports.default = parse;
+}
+
+export default parse

package/src/parsers/mikroorm.ts

@@ -0,0 +1,22 @@
+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,
+            'source': 'parser:mikroorm'
+        })
+    ]
+}
+
+export default parse

package/src/parsers/tsoa.ts

@@ -0,0 +1,27 @@
+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 💩
+    return [
+        new Problem({
+            ...otherErrors.inputValidationError,
+            'detail': input.message,
+            'status': input.status,
+            'data': {
+                'fields': input.fields,
+            },
+            'stack': input.stack,
+            'errorObject': input,
+            'source': 'parser:tsoa'
+        })
+    ]
+}
+
+export default parse

package/src/parsers/zod.ts

@@ -0,0 +1,23 @@
+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`,
+        'stack': input.stack,
+        'errorObject': input,
+        'data': {
+            'issues': input.issues
+        },
+        'source': 'parser:zod'
+    })]
+}
+
+export default parse

package/src/problem.ts

@@ -0,0 +1,70 @@
+import type { IProblem, ProblemOpts, JsonProblemOutput } from './typings/problem.js'
+import { isJsonProblem } from './util/getProblems.js'
+import { validateBasicInput } from './util/validation.js'
+import { version } from './util/version.js'
+
+export class Problem extends Error implements IProblem {
+    public type
+    public title
+    public status
+    public detail
+    public instance
+    public errorObject?: unknown
+    public readonly __problemVersion = version
+    public data: unknown = undefined
+    public source?: string
+
+    constructor(opts: ProblemOpts) {
+        const valid = validateBasicInput(opts)
+        if (valid !== true) throw valid
+
+        super(opts.detail ?? opts.title ?? 'HTTP Problem Details')
+        // TODO: Figure out if this is still necessary
+        Object.setPrototypeOf(this, new.target.prototype)
+
+        this.type = opts.type
+        this.title = opts.title
+        this.status = opts.status
+
+        if (opts.detail) this.detail = opts.detail
+        if (opts.instance) this.instance = opts.instance
+        if (opts.errorObject) this.errorObject = opts.errorObject
+        if (opts.source) this.source = opts.source
+
+        if (opts.stack) {
+            this.stack = opts.stack
+        } else if (opts.errorObject && typeof opts.errorObject === 'object' && 'stack' in opts.errorObject && typeof opts.errorObject.stack === 'string') {
+            this.stack = opts.errorObject.stack
+        } else {
+            if (typeof Error.captureStackTrace === 'function') {
+                Error.captureStackTrace(this, this.constructor)
+            } else {
+                this.stack = new Error(opts.detail ?? opts.title ?? 'HTTP Problem Details').stack
+            }
+        }
+
+        if (opts.data) this.data = opts.data
+
+        if (opts.data && opts.data instanceof Problem) {
+            console.warn(new Error('@emoyly/problem -> Problem: Problem instance passed in "data" to new Problem. This probably means something went wrong.'))
+        } else if (opts.data && isJsonProblem(opts.data)){
+            console.warn(new Error('@emoyly/problem -> Problem: Something which looks like a "JSON Problem" passed in "data" to new Problem. This probably means something went wrong.'))
+        }
+    }
+
+    public toObject = (): JsonProblemOutput => {
+        const out: JsonProblemOutput = {
+            'type': this.type,
+            'title': this.title,
+            'status': this.status,
+            '__problemVersion': this.__problemVersion,
+        }
+
+        if (this.detail) out.detail = this.detail
+        if (this.instance) out.instance = this.instance
+        if (this.source) out.source = this.source
+        if (this.data) out.data = this.data
+
+        return out
+    }
+}

package/src/typings/codes.ts

@@ -0,0 +1,7 @@
+import type { ProblemOpts } from './problem.js'
+
+export type CodeOpts = Omit<ProblemOpts, 'instance' | 'stack' | '__problemVersion' | 'source' | 'data'>
+
+export interface Codes {
+    [key: number | string]: CodeOpts | undefined
+}

package/src/typings/index.ts

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

package/{esm/typings/middleware.d.ts → src/typings/middleware.ts}

@@ -1,11 +1,14 @@
-import type { Problem } from '../problem.js';
-import type { Parser } from './parser.js';
+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[];
+    parsers: Parser[]
 }
-export type PartialMiddlewareOptions = Partial<MiddlewareOptions>;
-export type ProblemListener = (problems: Problem[]) => void;
+
+export type PartialMiddlewareOptions = Partial<MiddlewareOptions>
+
+export type ProblemListener = (problems: Problem[]) => void

package/src/typings/parser.ts

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

package/{esm/typings/problem.d.ts → src/typings/problem.ts}

@@ -1,5 +1,5 @@
 /**
- * @param {string} type - A URI refrence that identifies the problem type.
+ * @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
@@ -8,28 +8,29 @@
  * @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;
-    source?: string;
+    type: string
+    title: string
+    status: number
+    detail?: string
+    instance?: string
+    stack?: string
+    errorObject?: unknown
+    __problemVersion: string
+    data?: unknown
+    source?: string
 }
+
 /**
  * Returned by `toObject()` function on `Problem` class.
  */
-export type JsonProblemOutput = Omit<IProblem, 'stack' | 'errorObject'>;
+export type JsonProblemOutput = Omit<IProblem, 'stack' | 'errorObject'>
+
 /**
  * Input for creating a Problem instance from JSON. Please use `createFromJson` function for this.
  * Extra data is allowed, and will be stored in the `data` property.
  */
-export type JsonProblemInput = Omit<IProblem, '__problemVersion'> & {
-    __problemVersion?: string;
-    [key: string]: unknown;
-};
-export type ProblemOpts = Omit<IProblem, '__problemVersion'>;
+export type JsonProblemInput = Omit<IProblem, '__problemVersion'> & { __problemVersion?: string, [key: string]: unknown }
+
+export type ProblemOpts = Omit<IProblem, '__problemVersion'>

package/src/util/getProblems.ts

@@ -0,0 +1,62 @@
+import { Problem } from '../problem.js'
+import { Parser } from '../typings/parser.js'
+import { JsonProblemInput } from '../typings/problem.js'
+import { isProblemArray } from './problemArray.js'
+import { validateBasicInput } from './validation.js'
+
+export function isJsonProblem(input: unknown): input is JsonProblemInput {
+    return validateBasicInput(input) === true
+}
+
+export function createFromJson({ title, type, instance, detail, status, data: _data, __problemVersion, source, errorObject, stack, ...extras }: JsonProblemInput): Problem {
+    let data: unknown
+
+    const extraKeys = Object.keys(extras)
+
+    if /* No extras, just use data */ (extraKeys.length < 1) {
+        data = _data
+    } else if /* Extras but no data, just use extras */ ((_data === undefined || _data === null)) {
+        data = extras
+    } else if /* Data is not object we can merge with, and we do have extras */ (typeof _data !== 'object' || Array.isArray(_data) || Object.keys(_data).some(val => extraKeys.includes(val))) {
+        data = { original: _data, extras }
+    } else {
+        data = { ...extras, ..._data }
+    }
+
+    // TODO: Validate that source, errorObject and stack should actually be passed through
+    return new Problem({ title, type, instance, detail, status, data, source, errorObject, stack })
+}
+
+/**
+ * Get an array of Problems from any 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

@@ -0,0 +1,5 @@
+export * from './getProblems.js'
+export * from './problemArray.js'
+export * from './misc.js'
+export * from './validation.js'
+export { major as majorVersion, version } from './version.js'

package/src/util/misc.ts

@@ -0,0 +1,20 @@
+import * as allCodes from '../defaults/index.js'
+import { Codes, CodeOpts } from '../typings/index.js'
+
+export function getCodeDefaults(statusCode: number | string): CodeOpts | undefined {
+    for (const key in allCodes) {
+        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) continue
+
+        return code
+    }
+}
+

package/{cjs/util/problemArray.js → src/util/problemArray.ts}

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isProblemArray = isProblemArray;
-const problem_js_1 = require("../problem.js");
+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.
  */
-function isProblemArray(input, allowEmpty) {
-    if (!Array.isArray(input))
-        return false;
+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;
+            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 allowEmpty
     }
-    return input.every(val => val instanceof problem_js_1.Problem);
+
+    return input.every(val => val instanceof Problem)
 }

package/src/util/validation.ts

@@ -0,0 +1,39 @@
+export class ProblemValidationError extends Error {
+    errors: string[]
+
+    constructor(errors: string[]) {
+        super(`Problem input is invalid:\n${errors.join('\n')}`)
+        this.errors = errors
+    }
+}
+
+const requiredStrings = ['title', 'type'] as const
+const optionalStrings = ['detail', '__problemVersion', 'instance', 'stack', 'source'] as const
+
+export function validateBasicInput(input: unknown): true | ProblemValidationError {
+    const errors: string[] = []
+
+    if (input === null) {
+        errors.push('Input is null')
+        return new ProblemValidationError(errors)
+    }
+    if (typeof input !== 'object') {
+        errors.push('Input is not an object')
+        return new ProblemValidationError(errors)
+    }
+
+    const missingRequired = requiredStrings.filter(val => typeof input[val as keyof typeof input] !== 'string')
+    for (const miss of missingRequired) {
+        errors.push(`"${miss}" is missing or not a string`)
+    }
+
+    const wrongOptional = optionalStrings.filter((val) => val in input && input[val as keyof typeof input] !== undefined && input[val as keyof typeof input] !== null && typeof input[val as keyof typeof input] !== 'string')
+    for (const wrong of wrongOptional) {
+        errors.push(`"${wrong}" is set, and is not a string`)
+    }
+
+    if (!('status' in input) || typeof input.status !== 'number') errors.push('Status is not a number')
+
+    if (errors.length > 0) return new ProblemValidationError(errors)
+    return true
+}

package/src/util/version.ts

@@ -0,0 +1,2 @@
+export const version = '9.0.0'
+export const major = Number(version.split('.')[0])

package/cjs/defaults/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.otherErrors = exports.codesNginx = exports.codesIis = exports.codesCloudflare = exports.codesAws = exports.codes5xx = exports.codes4xx = void 0;
-var _4xx_js_1 = require("../defaults/4xx.js");
-Object.defineProperty(exports, "codes4xx", { enumerable: true, get: function () { return _4xx_js_1.statusCodes; } });
-var _5xx_js_1 = require("../defaults/5xx.js");
-Object.defineProperty(exports, "codes5xx", { enumerable: true, get: function () { return _5xx_js_1.statusCodes; } });
-var aws_js_1 = require("../defaults/aws.js");
-Object.defineProperty(exports, "codesAws", { enumerable: true, get: function () { return aws_js_1.statusCodes; } });
-var cloudflare_js_1 = require("../defaults/cloudflare.js");
-Object.defineProperty(exports, "codesCloudflare", { enumerable: true, get: function () { return cloudflare_js_1.statusCodes; } });
-var iis_js_1 = require("../defaults/iis.js");
-Object.defineProperty(exports, "codesIis", { enumerable: true, get: function () { return iis_js_1.statusCodes; } });
-var nginx_js_1 = require("../defaults/nginx.js");
-Object.defineProperty(exports, "codesNginx", { enumerable: true, get: function () { return nginx_js_1.statusCodes; } });
-var others_js_1 = require("../defaults/others.js");
-Object.defineProperty(exports, "otherErrors", { enumerable: true, get: function () { return others_js_1.otherErrors; } });

package/cjs/index.js

@@ -1,22 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaults = exports.Problem = void 0;
-var problem_js_1 = require("./problem.js");
-Object.defineProperty(exports, "Problem", { enumerable: true, get: function () { return problem_js_1.Problem; } });
-exports.defaults = require("./defaults/index.js");
-__exportStar(require("./typings/index.js"), exports);
-__exportStar(require("./util/index.js"), exports);

package/cjs/middleware/axios.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AxiosMiddleware = void 0;
-const base_js_1 = require("./base.js");
-const axios_js_1 = require("../parsers/axios.js");
-class AxiosMiddleware extends base_js_1.MiddlewareBase {
-    name = 'axios';
-    constructor(options) {
-        super({
-            'parsers': [axios_js_1.default]
-        }, options);
-    }
-    interceptor = async (error) => {
-        const problems = this.parse(error);
-        this.emit(problems);
-        return Promise.reject(problems);
-    };
-    /**
-     * @example instance.interceptors.response.use(...middleware.use())
-     */
-    use = () => [undefined, this.interceptor];
-}
-exports.AxiosMiddleware = AxiosMiddleware;

package/cjs/middleware/base.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiddlewareBase = void 0;
-const index_js_1 = require("../defaults/index.js");
-const problem_js_1 = require("../problem.js");
-const getProblems_js_1 = require("../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
- */
-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 = (input) => {
-        const problems = (0, getProblems_js_1.getProblems)(input, this.options.parsers);
-        if (!problems || !Array.isArray(problems) || problems.length < 1) {
-            if (this.enableFallback)
-                return [new problem_js_1.Problem({
-                        ...this.fallback,
-                        'errorObject': input,
-                        'source': `middleware:${this.name}`
-                    })];
-            return [];
-        }
-        for (const p of problems) {
-            if (!p.source)
-                p.source = `middleware:${this.name}`;
-        }
-        return problems;
-    };
-    fallback = index_js_1.otherErrors.unknown;
-    problemListeners = [];
-    emit = (list) => {
-        for (const listener of this.problemListeners) {
-            listener(list);
-        }
-    };
-    /**
-     * Listen to problems
-     */
-    onProblem = (listener) => {
-        this.problemListeners.push(listener);
-    };
-    /**
-     * Un-listen to problems
-     */
-    offProblem = (listener) => {
-        const idx = this.problemListeners.findIndex(val => val === listener);
-        if (idx < 0 || isNaN(idx))
-            return;
-        this.problemListeners.splice(idx, 1);
-    };
-}
-exports.MiddlewareBase = MiddlewareBase;

package/cjs/middleware/express.d.ts

@@ -1,19 +0,0 @@
-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;
-}