@emoyly/problem 4.1.7 → 4.1.10

package/dist/defaults/index.js

@@ -0,0 +1,17 @@
+"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_1 = require("../defaults/4xx");
+Object.defineProperty(exports, "codes4xx", { enumerable: true, get: function () { return _4xx_1.statusCodes; } });
+var _5xx_1 = require("../defaults/5xx");
+Object.defineProperty(exports, "codes5xx", { enumerable: true, get: function () { return _5xx_1.statusCodes; } });
+var aws_1 = require("../defaults/aws");
+Object.defineProperty(exports, "codesAws", { enumerable: true, get: function () { return aws_1.statusCodes; } });
+var cloudflare_1 = require("../defaults/cloudflare");
+Object.defineProperty(exports, "codesCloudflare", { enumerable: true, get: function () { return cloudflare_1.statusCodes; } });
+var iis_1 = require("../defaults/iis");
+Object.defineProperty(exports, "codesIis", { enumerable: true, get: function () { return iis_1.statusCodes; } });
+var nginx_1 = require("../defaults/nginx");
+Object.defineProperty(exports, "codesNginx", { enumerable: true, get: function () { return nginx_1.statusCodes; } });
+var others_1 = require("../defaults/others");
+Object.defineProperty(exports, "otherErrors", { enumerable: true, get: function () { return others_1.otherErrors; } });

package/dist/defaults/nginx.d.ts

@@ -0,0 +1,32 @@
+export declare const statusCodes: {
+    444: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    494: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    495: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    496: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    497: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    499: {
+        status: number;
+        title: string;
+        type: string;
+    };
+};

package/dist/defaults/nginx.js

@@ -0,0 +1,36 @@
+"use strict";
+// Source: https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCodes = void 0;
+exports.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/dist/defaults/others.d.ts

@@ -0,0 +1,37 @@
+export declare const otherErrors: {
+    unknown: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    corsError: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    problemParseError: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    problemJsonError: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    notAnError: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    networkError: {
+        status: number;
+        title: string;
+        type: string;
+    };
+    inputValidationError: {
+        status: number;
+        title: string;
+        type: string;
+    };
+};

package/dist/defaults/others.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.otherErrors = void 0;
+exports.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/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.events = exports.defaults = exports.Problem = void 0;
+var problem_1 = require("./problem");
+Object.defineProperty(exports, "Problem", { enumerable: true, get: function () { return problem_1.Problem; } });
+exports.defaults = __importStar(require("./defaults"));
+var events_1 = require("./util/events");
+Object.defineProperty(exports, "events", { enumerable: true, get: function () { return __importDefault(events_1).default; } });
+__exportStar(require("./typings"), exports);

package/dist/middleware/axios.d.ts

@@ -0,0 +1,13 @@
+import type { PartialMiddlewareOptions } from '../typings/middleware';
+import { MiddlewareBase } from './base';
+declare type InterceptorArray = [undefined, (error: any) => Promise<never>];
+export declare class AxiosMiddleware extends MiddlewareBase {
+    name: string;
+    constructor(options?: PartialMiddlewareOptions);
+    interceptor: (error: any) => Promise<never>;
+    /**
+     * @example instance.interceptors.response.use(...middleware.use())
+     */
+    use: () => InterceptorArray;
+}
+export {};

package/dist/middleware/axios.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosMiddleware = void 0;
+const base_1 = require("./base");
+const axios_1 = __importDefault(require("../parsers/axios"));
+const events_1 = __importDefault(require("../util/events"));
+class AxiosMiddleware extends base_1.MiddlewareBase {
+    constructor(options) {
+        super({
+            'parsers': [axios_1.default]
+        }, options);
+        this.name = 'axios';
+        this.interceptor = (error) => __awaiter(this, void 0, void 0, function* () {
+            const problems = yield this.parse(error);
+            events_1.default.emit(problems);
+            return Promise.reject(problems);
+        });
+        /**
+         * @example instance.interceptors.response.use(...middleware.use())
+         */
+        this.use = () => [undefined, this.interceptor];
+    }
+}
+exports.AxiosMiddleware = AxiosMiddleware;

package/dist/middleware/base.d.ts

@@ -0,0 +1,24 @@
+import { Problem } from '../problem';
+import type { ProblemOpts } from '../typings';
+import type { MiddlewareOptions, PartialMiddlewareOptions } from '../typings/middleware';
+/**
+ * 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 declare 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: boolean;
+    constructor(defaultOptions: MiddlewareOptions, options?: PartialMiddlewareOptions);
+    /**
+     * Call this function when you want to use the middleware function
+     */
+    abstract use(): any;
+    /**
+     * Parse input using parsers
+     */
+    parse: (input: any) => Promise<Problem[]>;
+    fallback: ProblemOpts;
+}

package/dist/middleware/base.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareBase = void 0;
+const defaults_1 = require("../defaults");
+const problem_1 = require("../problem");
+const getProblems_1 = require("../util/getProblems");
+/**
+ * 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 {
+    constructor(defaultOptions, 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
+         */
+        this.enableFallback = true;
+        /**
+         * Parse input using parsers
+         */
+        this.parse = (input) => __awaiter(this, void 0, void 0, function* () {
+            const problems = [];
+            const prob = getProblems_1.getProblems(input);
+            if (prob)
+                return 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_1.Problem(Object.assign(Object.assign({}, this.fallback), { 'errorObject': input })));
+            }
+            return problems;
+        });
+        this.fallback = defaults_1.otherErrors.unknown;
+        this.options = Object.assign(Object.assign({}, defaultOptions), options);
+    }
+}
+exports.MiddlewareBase = MiddlewareBase;

package/dist/middleware/express.d.ts

@@ -0,0 +1,19 @@
+import type { NextFunction, Request, Response } from 'express';
+import type { PartialMiddlewareOptions } from '../typings/middleware';
+import { MiddlewareBase } from './base';
+export declare class ExpressMiddleware extends MiddlewareBase {
+    name: string;
+    middleware: (error: any, 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: any, 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/dist/middleware/express.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressMiddleware = void 0;
+const base_1 = require("./base");
+const problem_1 = require("../problem");
+const defaults_1 = require("../defaults");
+const events_1 = __importDefault(require("../util/events"));
+class ExpressMiddleware extends base_1.MiddlewareBase {
+    constructor(options) {
+        super({
+            'parsers': []
+        }, options);
+        this.name = 'express';
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.middleware = (error, req, res, next) => {
+            this.parse(error)
+                .then(problems => {
+                var _a, _b;
+                for (const problem of problems) {
+                    if (problem.instance === '/unknown') {
+                        problem.instance = req.originalUrl;
+                    }
+                }
+                events_1.default.emit(problems);
+                res
+                    .contentType('application/problem+json')
+                    .status((_b = (_a = problems[0]) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 500)
+                    .json(problems.map(val => val.toObject()));
+            })
+                .catch(err => {
+                res
+                    .contentType('application/problem+json')
+                    .status(500)
+                    .json([new problem_1.Problem(Object.assign(Object.assign({}, defaults_1.otherErrors.unknown), { 'instance': req.originalUrl, 'status': 500 })).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())
+         */
+        this.use = () => this.middleware;
+        /**
+         * 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)
+         */
+        this.notFound = (req, res, next) => {
+            const error = new problem_1.Problem(Object.assign(Object.assign({}, defaults_1.codes4xx[404]), { 'instance': req.originalUrl, 'detail': `No API endpoints exist on ${req.url} for request method ${req.method}` }));
+            return next(error);
+        };
+    }
+}
+exports.ExpressMiddleware = ExpressMiddleware;

package/dist/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@emoyly/problem",
+    "version": "4.1.6",
+    "description": "A simple error library based around the RFC-7807 standard with optional support for Sentry.io and Express",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "repository": "https://github.com/emoyly/problem",
+    "author": "Emil Petersen <emoyly@gmail.com>",
+    "license": "MIT",
+    "scripts": {
+        "build": "tsc",
+        "lint": "eslint src",
+        "copy": "node scripts/copy"
+    },
+    "devDependencies": {
+        "@mikro-orm/core": "^4.5.9",
+        "@types/express": "^4.17.11",
+        "@types/jsonwebtoken": "^8.5.1",
+        "@types/node": "^15.0.1",
+        "@typescript-eslint/eslint-plugin": "^4.22.0",
+        "@typescript-eslint/parser": "^4.22.0",
+        "eslint": "^7.25.0",
+        "fs-extra": "^9.1.0",
+        "jsonwebtoken": "^8.5.1",
+        "tsoa": "^3.7.0",
+        "typescript": "^4.2.4"
+    },
+    "peerDependencies": {
+        "@mikro-orm/core": "^4.5.9",
+        "jsonwebtoken": "^8.5.1",
+        "tsoa": "^3.7.0"
+    },
+    "peerDependenciesMeta": {
+        "@mikro-orm/core": {
+            "optional": true
+        },
+        "jsonwebtoken": {
+            "optional": true
+        },
+        "tsoa": {
+            "optional": true
+        }
+    },
+    "packageManager": "yarn@3.2.0"
+}

package/dist/parsers/axios.d.ts

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

package/dist/parsers/axios.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const others_1 = require("../defaults/others");
+const problem_1 = require("../problem");
+const getProblems_1 = require("../util/getProblems");
+const http_1 = require("./http");
+const parse = (input) => {
+    var _a, _b, _c, _d, _e, _f;
+    const request = input.request;
+    if ((_a = input === null || input === void 0 ? void 0 : input.response) === null || _a === void 0 ? void 0 : _a.data) {
+        const problems = getProblems_1.getProblems((_b = input === null || input === void 0 ? void 0 : input.response) === null || _b === void 0 ? void 0 : _b.data);
+        if (problems)
+            return problems;
+    }
+    if (input === null || input === void 0 ? void 0 : input.response) {
+        const url = `${(_c = input.config) === null || _c === void 0 ? void 0 : _c.baseURL}${(_d = input.config) === null || _d === void 0 ? void 0 : _d.url}`;
+        const problem = http_1.parseHTTPError({
+            'body': input.response.data,
+            'headers': input.response.headers,
+            'statusCode': input.response.status,
+            url
+        });
+        if (problem)
+            return [problem];
+    }
+    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_1.Problem(Object.assign(Object.assign({}, others_1.otherErrors.networkError), { 'instance': (_e = input === null || input === void 0 ? void 0 : input.config) === null || _e === void 0 ? void 0 : _e.url }))];
+        }
+        // Probably a ClientRequest
+        if (isNode && 'pipe' in request && 'destroy' in request) {
+            return [new problem_1.Problem(Object.assign(Object.assign({}, others_1.otherErrors.networkError), { 'instance': (_f = input === null || input === void 0 ? void 0 : input.config) === null || _f === void 0 ? void 0 : _f.url }))];
+        }
+    }
+    return [];
+};
+exports.default = parse;

package/dist/parsers/http.d.ts

@@ -0,0 +1,3 @@
+import { Problem } from '../problem';
+import type { HTTPErrorDetails } from '../typings/parser';
+export declare function parseHTTPError(input: HTTPErrorDetails): Problem | void;

package/dist/parsers/http.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHTTPError = void 0;
+const defaults_1 = require("../defaults");
+const problem_1 = require("../problem");
+const codes = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, defaults_1.codes4xx), defaults_1.codes5xx), defaults_1.codesAws), defaults_1.codesCloudflare), defaults_1.codesIis), defaults_1.codesNginx);
+function parseHTTPError(input) {
+    var _a;
+    if (input.statusCode) {
+        const found = (_a = Object.entries(codes).find(([key]) => { var _a; return key === ((_a = input.statusCode) === null || _a === void 0 ? void 0 : _a.toString()); })) === null || _a === void 0 ? void 0 : _a[1];
+        if (found)
+            return new problem_1.Problem(Object.assign({}, found));
+    }
+}
+exports.parseHTTPError = parseHTTPError;

package/dist/parsers/jsonwebtoken.d.ts

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

package/dist/parsers/jsonwebtoken.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const problem_1 = require("../problem");
+const jsonwebtoken_1 = require("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 jsonwebtoken_1.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_1.Problem(found.result)];
+        }
+    }
+    else if (input instanceof jsonwebtoken_1.TokenExpiredError && input.name === 'TokenExpiredError') {
+        return [new problem_1.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 jsonwebtoken_1.NotBeforeError && input.name === 'NotBeforeError') {
+        return [new problem_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 [];
+};
+exports.default = parse;

package/dist/parsers/mikroorm.d.ts

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

package/dist/parsers/mikroorm.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const problem_1 = require("../problem");
+const _4xx_1 = require("../defaults/4xx");
+const core_1 = require("@mikro-orm/core");
+// TODO: Make this less bad
+const parse = (input) => {
+    if (!(input instanceof core_1.NotFoundError)) {
+        return [];
+    }
+    return [
+        new problem_1.Problem(_4xx_1.statusCodes['404'])
+    ];
+};
+exports.default = parse;

package/dist/parsers/tsoa.d.ts

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