@tsed/platform-exceptions 8.0.1 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/platform-exceptions",
   "description": "Platform exceptions module for Ts.ED Framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -24,22 +25,22 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/schema": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/exceptions": "8.0.2",
+    "@tsed/schema": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "ajv": "^8.17.1",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/schema": "8.0.1"
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/exceptions": "8.0.2",
+    "@tsed/schema": "8.0.2"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

package/src/components/ErrorFilter.spec.ts

@@ -0,0 +1,56 @@
+import {ErrorFilter} from "./ErrorFilter.js";
+
+describe("ErrorFilter", () => {
+  it("should map error if error.errors is an object", () => {
+    const error = {
+      errors: {
+        "ingredients.0.product": {
+          stringValue:
+            "\"{\n  id: '5e9a0c1d5575346932e090f0',\n  label: 'Artichauts',\n  shelf: 'produce',\n  minimumQuantity: 0,\n  users: []\n}\"",
+          kind: "ObjectId",
+          value: {
+            id: "5e9a0c1d5575346932e090f0",
+            label: "Artichauts",
+            shelf: "produce",
+            minimumQuantity: 0,
+            users: []
+          },
+          path: "product",
+          reason: {}
+        }
+      },
+      _message: "Recipe validation failed",
+      name: "ValidationError",
+      message:
+        "Recipe validation failed: ingredients.0.product: Cast to ObjectId failed for value \"{\n  id: '5e9a0c1d5575346932e090f0',\n  label: 'Artichauts',\n  shelf: 'produce',\n  minimumQuantity: 0,\n  users: []\n}\" at path \"product\""
+    };
+    const errorFilterInstance = new ErrorFilter();
+    expect(errorFilterInstance.mapError(error).errors).toEqual([error.errors]);
+  });
+  it("should map error if has error.code", () => {
+    const error = {
+      errors: {
+        "ingredients.0.product": {
+          stringValue:
+            "\"{\n  id: '5e9a0c1d5575346932e090f0',\n  label: 'Artichauts',\n  shelf: 'produce',\n  minimumQuantity: 0,\n  users: []\n}\"",
+          kind: "ObjectId",
+          value: {
+            id: "5e9a0c1d5575346932e090f0",
+            label: "Artichauts",
+            shelf: "produce",
+            minimumQuantity: 0,
+            users: []
+          },
+          path: "product",
+          reason: {}
+        }
+      },
+      _message: "Recipe validation failed",
+      code: "ValidationError",
+      message:
+        "Recipe validation failed: ingredients.0.product: Cast to ObjectId failed for value \"{\n  id: '5e9a0c1d5575346932e090f0',\n  label: 'Artichauts',\n  shelf: 'produce',\n  minimumQuantity: 0,\n  users: []\n}\" at path \"product\""
+    };
+    const errorFilterInstance = new ErrorFilter();
+    expect(errorFilterInstance.mapError(error).errors).toEqual([error.errors]);
+  });
+});

package/src/components/ErrorFilter.ts

@@ -0,0 +1,44 @@
+import {Env} from "@tsed/core";
+import {BaseContext} from "@tsed/di";
+
+import {Catch} from "../decorators/catch.js";
+import type {ExceptionFilterMethods} from "../interfaces/ExceptionFilterMethods.js";
+
+@Catch(Error)
+export class ErrorFilter implements ExceptionFilterMethods {
+  catch(error: any, ctx: BaseContext): void {
+    const {response, logger, env} = ctx;
+    const err = this.mapError(error, env);
+
+    response
+      .setHeaders(this.getHeaders(error))
+      .status(err.status)
+      .contentType("application/json")
+      .body(env === Env.PROD ? "InternalServerError" : err);
+  }
+
+  mapError(error: any, env?: Env) {
+    return {
+      name: error.origin?.name || error.name || error.code,
+      message: error.message,
+      status: error.status || error.statusCode || 500,
+      errors: this.getErrors(error),
+      stack: env === Env.DEV ? error.stack : undefined
+    };
+  }
+
+  protected getErrors(error: any) {
+    return [error, error.origin].filter(Boolean).reduce((errs, {errors}: any) => {
+      return errs.concat(errors).filter(Boolean);
+    }, []);
+  }
+
+  protected getHeaders(error: any) {
+    return [error, error.origin].filter(Boolean).reduce((obj, {headers}: any) => {
+      return {
+        ...obj,
+        ...(headers || {})
+      };
+    }, {});
+  }
+}

package/src/components/ExceptionFilter.ts

@@ -0,0 +1,15 @@
+import {BaseContext} from "@tsed/di";
+import {Exception} from "@tsed/exceptions";
+
+import {Catch} from "../decorators/catch.js";
+import {ErrorFilter} from "./ErrorFilter.js";
+
+@Catch(Exception)
+export class ExceptionFilter extends ErrorFilter {
+  catch(error: Exception, ctx: BaseContext) {
+    const {response, env} = ctx;
+    const err = this.mapError(error, env);
+
+    response.setHeaders(this.getHeaders(error)).contentType("application/json").status(error.status).body(err);
+  }
+}

package/src/components/MongooseErrorFilter.ts

@@ -0,0 +1,12 @@
+import {BaseContext} from "@tsed/di";
+import {BadRequest} from "@tsed/exceptions";
+
+import {Catch} from "../decorators/catch.js";
+import {ErrorFilter} from "./ErrorFilter.js";
+
+@Catch("MongooseError", "MongoError")
+export class MongooseErrorFilter extends ErrorFilter {
+  catch(error: Error, ctx: BaseContext) {
+    return super.catch(new BadRequest(error.message, error), ctx);
+  }
+}

package/src/components/StringErrorFilter.spec.ts

@@ -0,0 +1,24 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {StringErrorFilter} from "./StringErrorFilter.js";
+
+describe("StringErrorFilter", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+  it("should map message", () => {
+    const instance = new StringErrorFilter();
+    const ctx = PlatformTest.createRequestContext();
+
+    instance.catch("message", ctx);
+
+    expect(ctx.response.getBody()).toEqual("message");
+  });
+  it("should map undefined message", () => {
+    const instance = new StringErrorFilter();
+    const ctx = PlatformTest.createRequestContext();
+
+    instance.catch(undefined as any, ctx);
+
+    expect(ctx.response.getBody()).toEqual("");
+  });
+});

package/src/components/StringErrorFilter.ts

@@ -0,0 +1,13 @@
+import {BaseContext} from "@tsed/di";
+
+import {Catch} from "../decorators/catch.js";
+import type {ExceptionFilterMethods} from "../interfaces/ExceptionFilterMethods.js";
+
+const toHTML = (message = "") => message.replace(/\n/gi, "<br />");
+
+@Catch(String)
+export class StringErrorFilter implements ExceptionFilterMethods {
+  catch(error: string, ctx: BaseContext): void {
+    ctx.response.status(404).body(toHTML(error));
+  }
+}

package/src/decorators/catch.ts

@@ -0,0 +1,18 @@
+import {Type} from "@tsed/core";
+import {injectable, registerProvider} from "@tsed/di";
+
+import {registerExceptionType} from "../domain/ExceptionFiltersContainer.js";
+
+/**
+ * Register a new class to handle an specific exception.
+ * @decorator
+ * @param types
+ */
+export function Catch(...types: (Type<Error | any> | string)[]) {
+  return (target: any) => {
+    types.forEach((type) => {
+      registerExceptionType(type, target as any);
+    });
+    injectable(target).class(target);
+  };
+}

package/src/domain/ExceptionFiltersContainer.ts

@@ -0,0 +1,18 @@
+import {Type} from "@tsed/core";
+
+import type {ExceptionFilterMethods} from "../interfaces/ExceptionFilterMethods.js";
+/**
+ * @ignore
+ */
+export type ExceptionFilterKey = Type<any> | Symbol | string;
+/**
+ * @ignore
+ */
+// tslint:disable-next-line:variable-name
+export const ExceptionFiltersContainer = new Map<ExceptionFilterKey, Type<ExceptionFilterMethods>>();
+/**
+ * @ignore
+ */
+export function registerExceptionType(type: ExceptionFilterKey, token: Type<ExceptionFilterMethods>) {
+  ExceptionFiltersContainer.set(type, token);
+}

package/src/domain/ExceptionSchema.spec.ts

@@ -0,0 +1,217 @@
+import "./ExceptionSchema";
+
+import SwaggerParser from "@apidevtools/swagger-parser";
+import {BadRequest, Exception} from "@tsed/exceptions";
+import {getJsonSchema, getSpec, OperationPath, Path, Returns, SpecTypes} from "@tsed/schema";
+import {Ajv} from "ajv";
+import fs from "fs-extra";
+
+const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
+
+function getAjv() {
+  return new Ajv({
+    verbose: false,
+    coerceTypes: true
+  });
+}
+
+const validateSpec = async (spec: any) => {
+  const file = rootDir + "/spec.json";
+  spec = {
+    ...spec
+  };
+  try {
+    spec.openapi = "3.0.1";
+    spec.info = {
+      title: "Title",
+      description: "Description",
+      termsOfService: "termsOfService",
+      contact: {
+        email: "apiteam@swagger.io"
+      },
+      license: {
+        name: "Apache 2.0",
+        url: "http://www.apache.org/licenses/LICENSE-2.0.html"
+      },
+      version: "1.0.0"
+    };
+
+    fs.writeJsonSync(file, spec, {encoding: "utf8"});
+    await SwaggerParser.validate(file);
+    fs.unlinkSync(file);
+
+    return true;
+  } catch (er) {
+    console.error(er);
+    // unlinkSync(file);
+
+    return er;
+  }
+};
+
+describe("ExceptionSchema", () => {
+  it("should generate the right json schema", () => {
+    const schema = getJsonSchema(Exception);
+
+    expect(schema).toEqual({
+      definitions: {
+        GenericError: {
+          additionalProperties: true,
+          properties: {
+            message: {
+              description: "An error message",
+              minLength: 1,
+              type: "string"
+            },
+            name: {
+              description: "The error name",
+              minLength: 1,
+              type: "string"
+            }
+          },
+          required: ["name", "message"],
+          type: "object"
+        }
+      },
+      properties: {
+        errors: {
+          description: "A list of related errors",
+          items: {
+            $ref: "#/definitions/GenericError"
+          },
+          type: "array"
+        },
+        message: {
+          description: "An error message",
+          minLength: 1,
+          type: "string"
+        },
+        name: {
+          description: "The error name",
+          minLength: 1,
+          type: "string"
+        },
+        stack: {
+          description: "The stack trace (only in development mode)",
+          type: "string"
+        },
+        status: {
+          description: "The status code of the exception",
+          type: "number"
+        }
+      },
+      required: ["name", "message", "status"],
+      type: "object"
+    });
+
+    const ajv = getAjv();
+    ajv.validate(schema, {status: 400});
+    expect(ajv.errors).toEqual([
+      {
+        instancePath: "",
+        keyword: "required",
+        message: "must have required property 'name'",
+        params: {
+          missingProperty: "name"
+        },
+        schemaPath: "#/required"
+      }
+    ]);
+  });
+
+  it("should generate the right spec - OS3", async () => {
+    @Path("/")
+    class MyController {
+      @OperationPath("GET", "/")
+      @(Returns(400, BadRequest).Description("BadRequest"))
+      get() {}
+    }
+
+    const spec = getSpec(MyController, {specType: SpecTypes.OPENAPI});
+    expect(spec).toEqual({
+      components: {
+        schemas: {
+          GenericError: {
+            additionalProperties: true,
+            properties: {
+              message: {
+                description: "An error message",
+                minLength: 1,
+                type: "string"
+              },
+              name: {
+                description: "The error name",
+                minLength: 1,
+                type: "string"
+              }
+            },
+            required: ["name", "message"],
+            type: "object"
+          },
+          BadRequest: {
+            properties: {
+              errors: {
+                description: "A list of related errors",
+                items: {
+                  $ref: "#/components/schemas/GenericError"
+                },
+                type: "array"
+              },
+              message: {
+                description: "An error message",
+                minLength: 1,
+                type: "string"
+              },
+              name: {
+                default: "BAD_REQUEST",
+                description: "The error name",
+                example: "BAD_REQUEST",
+                minLength: 1,
+                type: "string"
+              },
+              stack: {
+                description: "The stack trace (only in development mode)",
+                type: "string"
+              },
+              status: {
+                default: 400,
+                description: "The status code of the exception",
+                example: 400,
+                type: "number"
+              }
+            },
+            required: ["name", "message", "status"],
+            type: "object"
+          }
+        }
+      },
+      paths: {
+        "/": {
+          get: {
+            operationId: "myControllerGet",
+            parameters: [],
+            responses: {
+              "400": {
+                content: {
+                  "application/json": {
+                    schema: {
+                      $ref: "#/components/schemas/BadRequest"
+                    }
+                  }
+                },
+                description: "BadRequest"
+              }
+            },
+            tags: ["MyController"]
+          }
+        }
+      },
+      tags: [
+        {
+          name: "MyController"
+        }
+      ]
+    });
+    expect(await validateSpec(spec)).toEqual(true);
+  });
+});

package/src/domain/ExceptionSchema.ts

@@ -0,0 +1,36 @@
+import * as Exceptions from "@tsed/exceptions";
+import {Exception} from "@tsed/exceptions";
+import {array, defineStatusModel, from, getStatusConstant, number, object, string} from "@tsed/schema";
+
+/**
+ * @ignore
+ */
+const ErrorSchema = object({
+  name: string().required().description("The error name"),
+  message: string().required().description("An error message")
+})
+  .label("GenericError")
+  .unknown();
+
+from(Exception).properties({
+  name: string().required().description("The error name"),
+  message: string().required().description("An error message"),
+  status: number().required().description("The status code of the exception"),
+  errors: array().items(ErrorSchema).description("A list of related errors"),
+  stack: string().description("The stack trace (only in development mode)")
+});
+
+// Auto load models for all Exceptions
+Object.values(Exceptions).forEach((target: any) => {
+  if (target !== Exception && target.STATUS) {
+    if (target.STATUS > 302) {
+      const name = getStatusConstant(target.STATUS);
+      from(target).properties({
+        name: string().required().example(name).default(name).description("The error name"),
+        status: number().required().example(target.STATUS).default(target.STATUS).description("The status code of the exception")
+      });
+
+      defineStatusModel(target.STATUS, target);
+    }
+  }
+});

package/src/errors/ResourceNotFound.ts

@@ -0,0 +1,11 @@
+import {NotFound} from "@tsed/exceptions";
+
+export class ResourceNotFound extends NotFound {
+  readonly url: string;
+
+  constructor(url: string) {
+    super(`Resource "${url}" not found`);
+
+    this.url = url;
+  }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./components/ErrorFilter.js";
+export * from "./components/ExceptionFilter.js";
+export * from "./components/MongooseErrorFilter.js";
+export * from "./components/StringErrorFilter.js";
+export * from "./decorators/catch.js";
+export * from "./domain/ExceptionFiltersContainer.js";
+export * from "./domain/ExceptionSchema.js";
+export * from "./errors/ResourceNotFound.js";
+export * from "./interfaces/ExceptionFilterMethods.js";
+export * from "./services/PlatformExceptions.js";
+export {PlatformExceptions as default} from "./services/PlatformExceptions.js";

package/src/interfaces/ExceptionFilterMethods.ts

@@ -0,0 +1,5 @@
+import {DIContext} from "@tsed/di";
+
+export interface ExceptionFilterMethods<T = unknown> {
+  catch(error: T, ctx: DIContext): void;
+}

package/src/services/PlatformExceptions.spec.ts

@@ -0,0 +1,197 @@
+import {Env} from "@tsed/core";
+import {BadRequest} from "@tsed/exceptions";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {ValidationError} from "@tsed/platform-params";
+
+import {PlatformExceptions} from "./PlatformExceptions.js";
+
+describe("PlatformExceptions", () => {
+  describe("Env.TEST", () => {
+    beforeEach(() => PlatformTest.create());
+    afterEach(() => PlatformTest.reset());
+    beforeEach(() => {
+      vi.spyOn(PlatformTest.injector.logger, "error").mockReturnValue(undefined);
+    });
+
+    it("should map string error", () => {
+      const platformExceptions = PlatformTest.get<PlatformExceptions>(PlatformExceptions);
+
+      const ctx = PlatformTest.createRequestContext();
+      vi.spyOn(ctx.response, "body").mockReturnThis();
+      vi.spyOn(ctx.response, "setHeaders").mockReturnThis();
+      vi.spyOn(ctx.response, "status").mockReturnThis();
+      vi.spyOn(ctx.response, "contentType").mockReturnThis();
+
+      const error = "MyError";
+
+      platformExceptions.catch(error, ctx);
+
+      expect(ctx.response.body).toHaveBeenCalledWith("MyError");
+    });
+    it("should map exception", () => {
+      const middleware = PlatformTest.get<PlatformExceptions>(PlatformExceptions);
+
+      const ctx = PlatformTest.createRequestContext();
+      vi.spyOn(ctx.response, "body").mockReturnThis();
+      vi.spyOn(ctx.response, "setHeaders").mockReturnThis();
+      vi.spyOn(ctx.response, "status").mockReturnThis();
+      vi.spyOn(ctx.response, "contentType").mockReturnThis();
+
+      const origin = new ValidationError("wrong ID", [
+        {
+          path: "id",
+          error: "format"
+        }
+      ]);
+
+      const error = new BadRequest("Bad request on ID", origin);
+      error.headers = {
+        "x-path": "id"
+      };
+
+      middleware.catch(error, ctx);
+
+      expect(ctx.response.setHeaders).toHaveBeenCalledWith({"x-path": "id"});
+      expect(ctx.response.body).toHaveBeenCalledWith({
+        errors: [
+          {
+            error: "format",
+            path: "id"
+          }
+        ],
+        message: "Bad request on ID, innerException: wrong ID",
+        name: "VALIDATION_ERROR",
+        status: 400,
+        stack: undefined
+      });
+    });
+    it("should map error", () => {
+      const middleware = PlatformTest.get<PlatformExceptions>(PlatformExceptions);
+
+      const ctx = PlatformTest.createRequestContext();
+      vi.spyOn(ctx.response, "body").mockReturnThis();
+      vi.spyOn(ctx.response, "setHeaders").mockReturnThis();
+      vi.spyOn(ctx.response, "status").mockReturnThis();
+      vi.spyOn(ctx.response, "contentType").mockReturnThis();
+
+      class Custom extends Error {}
+
+      const error = new Custom("My message");
+
+      middleware.catch(error, ctx);
+
+      expect(ctx.response.setHeaders).toHaveBeenCalledWith({});
+      expect(ctx.response.body).toHaveBeenCalledWith({
+        errors: [],
+        message: "My message",
+        name: "Error",
+        status: 500,
+        stack: undefined
+      });
+    });
+    it("should map error from given name", () => {
+      const middleware = PlatformTest.get<PlatformExceptions>(PlatformExceptions);
+
+      const ctx = PlatformTest.createRequestContext();
+      vi.spyOn(ctx.response, "body").mockReturnThis();
+      vi.spyOn(ctx.response, "setHeaders").mockReturnThis();
+      vi.spyOn(ctx.response, "status").mockReturnThis();
+      vi.spyOn(ctx.response, "contentType").mockReturnThis();
+
+      class MongooseError extends Error {}
+
+      const error = new MongooseError("My message");
+
+      middleware.catch(error, ctx);
+
+      expect(ctx.response.setHeaders).toHaveBeenCalledWith({});
+      expect(ctx.response.body).toHaveBeenCalledWith({
+        errors: [],
+        message: "My message, innerException: My message",
+        name: "Error",
+        stack: undefined,
+        status: 400
+      });
+    });
+    it("should map raw error", () => {
+      const platformExceptions = PlatformTest.get<PlatformExceptions>(PlatformExceptions);
+
+      const ctx = PlatformTest.createRequestContext();
+      vi.spyOn(ctx.response, "body").mockReturnThis();
+      vi.spyOn(ctx.response, "setHeaders").mockReturnThis();
+      vi.spyOn(ctx.response, "status").mockReturnThis();
+      vi.spyOn(ctx.response, "contentType").mockReturnThis();
+
+      const error = {
+        status: 413,
+        name: "PayloadTooLargeError",
+        message: "request entity too large"
+      };
+
+      platformExceptions.catch(error, ctx);
+
+      expect(ctx.response.body).toHaveBeenCalledWith({
+        errors: [],
+        message: "request entity too large",
+        name: "PayloadTooLargeError",
+        stack: undefined,
+        status: 413
+      });
+    });
+  });
+
+  describe("Env.PROD", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        env: Env.PROD
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+    it("should map error return internal error in prod profile", () => {
+      const middleware = PlatformTest.get<PlatformExceptions>(PlatformExceptions);
+
+      const ctx = PlatformTest.createRequestContext();
+      vi.spyOn(ctx.response, "body").mockReturnThis();
+      vi.spyOn(ctx.response, "setHeaders").mockReturnThis();
+      vi.spyOn(ctx.response, "status").mockReturnThis();
+      vi.spyOn(ctx.response, "contentType").mockReturnThis();
+
+      const error = new Error("My message");
+
+      middleware.catch(error, ctx);
+
+      expect(ctx.response.setHeaders).toHaveBeenCalledWith({});
+      expect(ctx.response.body).toHaveBeenCalledWith("InternalServerError");
+    });
+  });
+  describe("resourceNotFound()", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        env: Env.PROD
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+    it("should map error return internal error in prod profile", () => {
+      const middleware = PlatformTest.get<PlatformExceptions>(PlatformExceptions);
+
+      const ctx = PlatformTest.createRequestContext();
+      ctx.request.raw.url = "url";
+
+      vi.spyOn(ctx.response, "body").mockReturnThis();
+      vi.spyOn(ctx.response, "setHeaders").mockReturnThis();
+      vi.spyOn(ctx.response, "status").mockReturnThis();
+      vi.spyOn(ctx.response, "contentType").mockReturnThis();
+
+      middleware.resourceNotFound(ctx);
+
+      expect(ctx.response.setHeaders).toHaveBeenCalledWith({});
+      expect(ctx.response.body).toHaveBeenCalledWith({
+        errors: [],
+        message: 'Resource "url" not found',
+        name: "NOT_FOUND",
+        stack: undefined,
+        status: 404
+      });
+    });
+  });
+});

package/src/services/PlatformExceptions.ts

@@ -0,0 +1,53 @@
+import {ancestorsOf, classOf, nameOf} from "@tsed/core";
+import {DIContext, inject, injectable, type TokenProvider} from "@tsed/di";
+
+import {ErrorFilter} from "../components/ErrorFilter.js";
+import {ExceptionFilter} from "../components/ExceptionFilter.js";
+import {MongooseErrorFilter} from "../components/MongooseErrorFilter.js";
+import {StringErrorFilter} from "../components/StringErrorFilter.js";
+import {ExceptionFilterKey, ExceptionFiltersContainer} from "../domain/ExceptionFiltersContainer.js";
+import {ResourceNotFound} from "../errors/ResourceNotFound.js";
+
+/**
+ * Catch all errors and return the json error with the right status code when it's possible.
+ *
+ * @platform
+ */
+export class PlatformExceptions {
+  types: Map<ExceptionFilterKey, TokenProvider> = new Map();
+
+  constructor() {
+    ExceptionFiltersContainer.forEach((token, type) => {
+      this.types.set(type, token);
+    });
+  }
+
+  catch(error: unknown, ctx: DIContext) {
+    return this.resolve(error, ctx).catch(error, ctx);
+  }
+
+  resourceNotFound(ctx: DIContext) {
+    return this.catch(new ResourceNotFound(ctx.request.url), ctx);
+  }
+
+  protected resolve(error: any, ctx: DIContext) {
+    const name = nameOf(classOf(error));
+
+    if (name && this.types.has(name)) {
+      return inject(this.types.get(name)!);
+    }
+
+    const target = ancestorsOf(error)
+      .reverse()
+      .find((target) => this.types.has(target));
+
+    if (target) {
+      return inject(this.types.get(target)!);
+    }
+
+    // default
+    return inject(this.types.get(Error)!);
+  }
+}
+
+injectable(PlatformExceptions).imports([ErrorFilter, ExceptionFilter, MongooseErrorFilter, StringErrorFilter]);