@ogcio/fastify-error-handler 4.0.0

package/README.md

@@ -0,0 +1,33 @@
+# Fastify Error Handler
+
+This error handler package's goal is to standardize the management of the errors across Fastify services.
+
+## How to use it
+
+To use this package 2 steps are needed:
+- install the package with
+```
+npm i @ogcio/fastify-error-handler
+```
+
+- use the `initializeErrorHandler(server)` method to set the error handlers for the `fastify` server
+
+That's it!
+
+## How to raise errors
+
+To standardize error handling in the Fastify services, the suggested way to go is to raise exceptions by using the `HttpError` errors from the [fastify-sensible](https://github.com/fastify/fastify-sensible) package.
+
+It exposes some predefined error types
+
+```
+import { httpErrors } from "@fastify/sensible";
+......
+// predefined error
+throw httpErrors.notFound("Route not found");
+
+// custom error
+throw httpErrors.createError(404, "message", {additional: {data: "here"}});
+```
+
+The `error-handler` package is ready to manage the errors, log them and transform them in the output HTTP error you need.

package/__tests__/helpers/build-fastify.ts

@@ -0,0 +1,88 @@
+import { FastifyError, createError } from "@fastify/error";
+import { pino, DestinationStream } from "pino";
+import fastify, { FastifyInstance } from "fastify";
+import { initializeErrorHandler } from "../../src/index.js";
+import fastifySensible from "@fastify/sensible";
+import httpErrors from "http-errors";
+export const buildFastify = async (
+  loggerDestination?: DestinationStream
+): Promise<FastifyInstance> => {
+  const server = fastify({ logger: pino({}, loggerDestination) });
+  initializeErrorHandler(server as unknown as FastifyInstance);
+  await server.register(fastifySensible);
+  server.get("/error", async (request, _reply) => {
+    const parsed = request.query as { [x: string]: unknown };
+    const requestedStatusCode = Number(parsed["status_code"] ?? "500");
+    const requestedMessage = String(parsed["error_message"] ?? "WHOOOPS");
+
+    if (!parsed["status_code"]) {
+      throw new Error(requestedMessage);
+    }
+
+    throw createError(
+      "CUSTOM_CODE",
+      requestedMessage as string,
+      requestedStatusCode as number
+    )();
+  });
+
+  server.get("/validation", async (request, _reply) => {
+    const parsed = request.query as { [x: string]: unknown };
+    const requestedMessage = String(parsed["error_message"] ?? "WHOOOPS");
+
+    const error = createError(
+      "CUSTOM_CODE",
+      requestedMessage as string,
+      422,
+    )() as FastifyError & {
+      headers: { [x: string]: unknown };
+      status: number | undefined;
+    };
+
+    error.validation = [
+      {
+        keyword: "field",
+        instancePath: "the.instance.path",
+        schemaPath: "the.schema.path",
+        params: { field: "one", property: "two" },
+        message: requestedMessage,
+      },
+    ];
+    error.validationContext = "body";
+    error.status = 423;
+
+    throw error;
+  });
+
+  server.get("/life-events/custom", async (request, _reply) => {
+    const parsed = request.query as { [x: string]: unknown };
+    const requestedStatusCode = Number(parsed["status_code"] ?? "500");
+
+    throw server.httpErrors.createError(
+      requestedStatusCode as number,
+      "message"
+    );
+  });
+
+  server.get("/life-events/validation", async (_request, _reply) => {
+    throw server.httpErrors.createError(422, "message", {
+      validationErrors: [
+        { fieldName: "field", message: "error", validationRule: "equal" },
+      ],
+    });
+  });
+
+  server.get("/life-events/:errorCode", async (request, _reply) => {
+    const errorCode = Number((request.params! as { errorCode: string })
+      .errorCode);
+    if (!httpErrors[errorCode]) {
+      throw new Error("Wrong parameter");
+    }
+   
+    const errorObj = httpErrors[errorCode];
+
+    throw new errorObj("Failed Correctly!");
+  });
+
+  return server as unknown as FastifyInstance;
+};

package/__tests__/helpers/fastify-test-helpers.ts

@@ -0,0 +1,44 @@
+import { FastifyInstance } from "fastify";
+import { buildFastify } from "./build-fastify.js";
+export const DEFAULT_HOSTNAME = "localhost:80";
+export const DEFAULT_USER_AGENT = "lightMyRequest";
+export const DEFAULT_REQUEST_HEADERS = {
+  "user-agent": "lightMyRequest",
+  host: "localhost:80",
+};
+export const DEFAULT_CLIENT_IP = "127.0.0.1";
+export const DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8";
+export const DEFAULT_METHOD = "GET";
+export const DEFAULT_SCHEME = "http";
+export const DEFAULT_PATH = "/error";
+
+export interface TestingLoggerDestination {
+  loggerDestination: {
+    write: (_data: string) => number;
+  };
+  getLoggedRecords: () => string[];
+}
+
+export const getTestingDestinationLogger = (): TestingLoggerDestination => {
+  const testCaseRecords: string[] = [];
+  const getLoggedRecords = () => testCaseRecords;
+  const loggerDestination = {
+    write: (data: string) => testCaseRecords.push(data),
+  };
+
+  return { loggerDestination, getLoggedRecords };
+};
+
+export const initializeServer = async (): Promise<{
+  server: FastifyInstance;
+  loggingDestination: TestingLoggerDestination;
+}> => {
+  const loggingDestination = getTestingDestinationLogger();
+  const server =  await buildFastify(loggingDestination.loggerDestination);
+
+  return { server, loggingDestination };
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const parseLogEntry = (logEntry: string): { [x: string]: any } =>
+  JSON.parse(logEntry);

package/__tests__/initialize-error-handler.test.ts

@@ -0,0 +1,99 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  DEFAULT_METHOD,
+  DEFAULT_PATH,
+  initializeServer,
+} from "./helpers/fastify-test-helpers.js";
+import httpErrors from "http-errors";
+import { HttpErrorClasses } from "@ogcio/shared-errors";
+
+test("Common error is managed as expected", async (t) => {
+  const { server } = await initializeServer();
+  t.after(() => server.close());
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: DEFAULT_PATH,
+    query: { status_code: "500", error_message: "error message" },
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 500);
+  assert.deepStrictEqual(response.json(), {
+    code: HttpErrorClasses.ServerError,
+    detail: "error message",
+    requestId: "req-1",
+    name: "FastifyError",
+  });
+});
+
+test("Validation error is managed as a Life Events One", async (t) => {
+  const { server } = await initializeServer();
+  t.after(() => server.close());
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: "/validation",
+    query: { error_message: "error message" },
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 422);
+  assert.deepStrictEqual(response.json(), {
+    code: HttpErrorClasses.ValidationError,
+    detail: "error message",
+    requestId: "req-1",
+    name: "UnprocessableEntityError",
+    validation: [
+      {
+        fieldName: "the.instance.path",
+        message: "error message",
+        validationRule: "field",
+        additionalInfo: {
+          field: "one",
+          property: "two",
+        },
+      },
+    ],
+  });
+});
+
+test("If an error with status 200 is raised, it is managed as an unknown one", async (t) => {
+  const { server } = await initializeServer();
+  t.after(() => server.close());
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: DEFAULT_PATH,
+    query: { status_code: "200", error_message: "error message" },
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 500);
+  assert.deepStrictEqual(response.json(), {
+    code: HttpErrorClasses.UnknownError,
+    detail: "error message",
+    requestId: "req-1",
+    name: "FastifyError",
+  });
+});
+
+test("404 error is managed as expected", async (t) => {
+  const { server } = await initializeServer();
+  t.after(() => server.close());
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: "/this-path-does-not-exist",
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 404);
+  assert.deepStrictEqual(response.json(), {
+    code: HttpErrorClasses.NotFoundError,
+    detail: "Route not found: /this-path-does-not-exist",
+    requestId: "req-1",
+    name: new httpErrors[404]("TEMP").name,
+  });
+});

package/__tests__/life-events-error-handler.test.ts

@@ -0,0 +1,82 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  DEFAULT_METHOD,
+  initializeServer,
+} from "./helpers/fastify-test-helpers.js";
+import httpErrors from "http-errors";
+import * as sharedErrors from "@ogcio/shared-errors";
+
+const errorsProvider = [
+  { errorType: httpErrors[401], expectedStatusCode: 401 },
+  { errorType: httpErrors[403], expectedStatusCode: 403 },
+  { errorType: httpErrors[500], expectedStatusCode: 500 },
+  { errorType: httpErrors[404], expectedStatusCode: 404 },
+  { errorType: httpErrors[500], expectedStatusCode: 500 },
+  { errorType: httpErrors[502], expectedStatusCode: 502 },
+];
+
+errorsProvider.forEach((errorProv) =>
+  test(`Error is managed in the correct way - ${errorProv.errorType.name}`, async (t) => {
+    const { server } = await initializeServer();
+    t.after(() => server.close());
+
+    const errorInstance = new errorProv.errorType("message");
+
+    const response = await server.inject({
+      method: DEFAULT_METHOD,
+      url: `/life-events/${errorProv.expectedStatusCode}`,
+    });
+
+    assert.ok(typeof response !== "undefined");
+    assert.equal(response?.statusCode, errorProv.expectedStatusCode);
+    assert.deepStrictEqual(response.json(), {
+      code: sharedErrors.parseHttpErrorClass(errorProv.expectedStatusCode),
+      detail: "Failed Correctly!",
+      requestId: "req-1",
+      name: errorInstance.name,
+    });
+  })
+);
+
+test(`Custom error is managed based on parameters`, async (t) => {
+  const { server } = await initializeServer();
+  t.after(() => server.close());
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: `/life-events/custom`,
+    query: { status_code: "503" },
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 503);
+  assert.deepStrictEqual(response.json(), {
+    code: sharedErrors.parseHttpErrorClass(503),
+    detail: "message",
+    requestId: "req-1",
+    name: new httpErrors[503]("MOCK").name,
+  });
+});
+
+test(`Validation error is managed as expected`, async (t) => {
+  const { server } = await initializeServer();
+  t.after(() => server.close());
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: `/life-events/validation`,
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 422);
+  assert.deepStrictEqual(response.json(), {
+    code: sharedErrors.parseHttpErrorClass(422),
+    detail: "message",
+    requestId: "req-1",
+    name: new httpErrors[422]("MOCK").name,
+    validation: [
+      { fieldName: "field", message: "error", validationRule: "equal" },
+    ],
+  });
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { FastifyInstance } from "fastify";
+export declare const initializeErrorHandler: (server: FastifyInstance) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAM1C,eAAO,MAAM,sBAAsB,WAAY,eAAe,KAAG,IAGhE,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+import { initializeNotFoundHandler, setupErrorHandler } from "./initialize-error-handler.js";
+export const initializeErrorHandler = (server) => {
+    setupErrorHandler(server);
+    initializeNotFoundHandler(server);
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,MAAuB,EAAQ,EAAE;IACtE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC1B,yBAAyB,CAAC,MAAM,CAAC,CAAC;AACpC,CAAC,CAAC"}

package/dist/initialize-error-handler.d.ts

@@ -0,0 +1,13 @@
+import { FastifyInstance } from "fastify";
+import { HttpErrorClasses, ValidationErrorData } from "@ogcio/shared-errors";
+export interface OutputHttpError {
+    code: HttpErrorClasses;
+    detail: string;
+    requestId: string;
+    name: string;
+    validation?: ValidationErrorData[];
+    process?: string;
+}
+export declare const setupErrorHandler: (server: FastifyInstance) => void;
+export declare const initializeNotFoundHandler: (server: FastifyInstance) => void;
+//# sourceMappingURL=initialize-error-handler.d.ts.map

package/dist/initialize-error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize-error-handler.d.ts","sourceRoot":"","sources":["../src/initialize-error-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAEhB,MAAM,SAAS,CAAC;AAOjB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EAEpB,MAAM,sBAAsB,CAAC;AAI9B,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAOD,eAAO,MAAM,iBAAiB,WAAY,eAAe,KAAG,IAyC3D,CAAC;AAIF,eAAO,MAAM,yBAAyB,WAAY,eAAe,KAAG,IAUnE,CAAC"}

package/dist/initialize-error-handler.js

@@ -0,0 +1,118 @@
+import { setLoggingContext, getLoggingContextError, LogMessages, } from "@ogcio/fastify-logging-wrapper";
+import { parseHttpErrorClass, } from "@ogcio/shared-errors";
+import { isHttpError } from "http-errors";
+import { httpErrors } from "@fastify/sensible";
+// The error handler below is the same as the original one in Fastify,
+// just without unwanted log entries
+// I've opened an issue to fastify to ask them if we could avoid logging
+// those entries when disableRequestLogging is true
+// https://github.com/fastify/fastify/issues/5409
+export const setupErrorHandler = (server) => {
+    const setErrorHeaders = (error, reply) => {
+        const res = reply.raw;
+        let statusCode = res.statusCode;
+        statusCode = statusCode >= 400 ? statusCode : 500;
+        // treat undefined and null as same
+        if (error != null) {
+            if (error.headers !== undefined) {
+                reply.headers(error.headers);
+            }
+            if (error.status && error.status >= 400) {
+                statusCode = error.status;
+            }
+            else if (error.statusCode && error.statusCode >= 400) {
+                statusCode = error.statusCode;
+            }
+        }
+        res.statusCode = statusCode;
+        reply.statusCode = res.statusCode;
+    };
+    server.setErrorHandler(function (error, request, reply) {
+        if (isHttpError(error)) {
+            manageHttpError(error, request, reply);
+            return;
+        }
+        if (error.validation) {
+            const httpError = toOutputHttpValidationError(error);
+            manageHttpError(httpError, request, reply);
+            return;
+        }
+        setErrorHeaders(error, reply);
+        reply.send(getResponseFromFastifyError(error, request));
+    });
+};
+// The error handler below is the same as the original one in Fastify,
+// just without unwanted log entries
+export const initializeNotFoundHandler = (server) => {
+    server.setNotFoundHandler((request, reply) => {
+        const error = httpErrors.notFound(`Route not found: ${request.url}`);
+        setLoggingContext({
+            error,
+        });
+        request.log.error({ error: getLoggingContextError() }, LogMessages.Error);
+        manageHttpError(error, request, reply);
+    });
+};
+const getValidationFromFastifyError = (validationInput) => {
+    const output = [];
+    for (const input of validationInput) {
+        const key = input.params?.missingProperty ?? input.instancePath.split("/").pop();
+        const message = input.message ?? input.keyword;
+        if (key && typeof key === "string") {
+            output.push({
+                fieldName: key,
+                message,
+                validationRule: input.keyword,
+                additionalInfo: input.params,
+            });
+            continue;
+        }
+        output.push({
+            fieldName: input.schemaPath,
+            message,
+            validationRule: input.keyword,
+            additionalInfo: input.params,
+        });
+    }
+    return { validation: output };
+};
+const getResponseFromFastifyError = (error, request) => {
+    const output = {
+        code: parseHttpErrorClass(error.statusCode),
+        detail: error.message,
+        requestId: request.id,
+        name: error.name,
+    };
+    if (error.validation && error.validation.length > 0) {
+        output.validation = getValidationFromFastifyError(error.validation).validation;
+    }
+    return output;
+};
+const manageHttpError = (error, request, reply) => {
+    reply.raw.statusCode = error.statusCode;
+    reply.statusCode = error.statusCode;
+    const errorResponse = {
+        code: parseHttpErrorClass(error.statusCode),
+        detail: error.message,
+        requestId: request.id,
+        name: error.name,
+        process: error.errorProcess,
+    };
+    let validationErrors = error.validationErrors && error.validationErrors.length > 0
+        ? error.validationErrors
+        : undefined;
+    if (!validationErrors && error.validation && error.validation.length > 0) {
+        validationErrors = error.validation;
+    }
+    if (validationErrors) {
+        errorResponse.validation = validationErrors;
+    }
+    reply.status(error.statusCode).send(errorResponse);
+};
+const toOutputHttpValidationError = (error) => {
+    if (!error.validation) {
+        throw httpErrors.createError(500, "This is not a validation error");
+    }
+    return httpErrors.createError(422, error.message, getValidationFromFastifyError(error.validation));
+};
+//# sourceMappingURL=initialize-error-handler.js.map

package/dist/initialize-error-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize-error-handler.js","sourceRoot":"","sources":["../src/initialize-error-handler.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,WAAW,GACZ,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAGL,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAa,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAW1D,sEAAsE;AACtE,oCAAoC;AACpC,wEAAwE;AACxE,mDAAmD;AACnD,iDAAiD;AACjD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,MAAuB,EAAQ,EAAE;IACjE,MAAM,eAAe,GAAG,CACtB,KAIC,EACD,KAAmB,EACnB,EAAE;QACF,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;QACtB,IAAI,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;QAChC,UAAU,GAAG,UAAU,IAAI,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC;QAClD,mCAAmC;QACnC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;gBAChC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAC/B,CAAC;YACD,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;gBACxC,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC;YAC5B,CAAC;iBAAM,IAAI,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,UAAU,IAAI,GAAG,EAAE,CAAC;gBACvD,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;YAChC,CAAC;QACH,CAAC;QACD,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC;QAC5B,KAAK,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;IACpC,CAAC,CAAC;IAEF,MAAM,CAAC,eAAe,CAAC,UAAU,KAAK,EAAE,OAAO,EAAE,KAAK;QACpD,IAAI,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACvB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;YACvC,OAAO;QACT,CAAC;QACD,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,SAAS,GAAG,2BAA2B,CAAC,KAAK,CAAC,CAAC;YACrD,eAAe,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;YAC3C,OAAO;QACT,CAAC;QAED,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9B,KAAK,CAAC,IAAI,CAAC,2BAA2B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,sEAAsE;AACtE,oCAAoC;AACpC,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,MAAuB,EAAQ,EAAE;IACzE,MAAM,CAAC,kBAAkB,CAAC,CAAC,OAAuB,EAAE,KAAmB,EAAE,EAAE;QACzE,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,CAAC,oBAAoB,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QACrE,iBAAiB,CAAC;YAChB,KAAK;SACN,CAAC,CAAC;QAEH,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,sBAAsB,EAAE,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;QAC1E,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,6BAA6B,GAAG,CACpC,eAA+C,EACR,EAAE;IACzC,MAAM,MAAM,GAA0B,EAAE,CAAC;IAEzC,KAAK,MAAM,KAAK,IAAI,eAAe,EAAE,CAAC;QACpC,MAAM,GAAG,GACP,KAAK,CAAC,MAAM,EAAE,eAAe,IAAI,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;QACvE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC;QAC/C,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACnC,MAAM,CAAC,IAAI,CAAC;gBACV,SAAS,EAAE,GAAG;gBACd,OAAO;gBACP,cAAc,EAAE,KAAK,CAAC,OAAO;gBAC7B,cAAc,EAAE,KAAK,CAAC,MAAM;aAC7B,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QAED,MAAM,CAAC,IAAI,CAAC;YACV,SAAS,EAAE,KAAK,CAAC,UAAU;YAC3B,OAAO;YACP,cAAc,EAAE,KAAK,CAAC,OAAO;YAC7B,cAAc,EAAE,KAAK,CAAC,MAAM;SAC7B,CAAC,CAAC;IACL,CAAC;IAED,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;AAChC,CAAC,CAAC;AAEF,MAAM,2BAA2B,GAAG,CAClC,KAAmB,EACnB,OAAuB,EACN,EAAE;IACnB,MAAM,MAAM,GAAoB;QAC9B,IAAI,EAAE,mBAAmB,CAAC,KAAK,CAAC,UAAU,CAAC;QAC3C,MAAM,EAAE,KAAK,CAAC,OAAO;QACrB,SAAS,EAAE,OAAO,CAAC,EAAE;QACrB,IAAI,EAAE,KAAK,CAAC,IAAI;KACjB,CAAC;IACF,IAAI,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpD,MAAM,CAAC,UAAU,GAAG,6BAA6B,CAC/C,KAAK,CAAC,UAAU,CACjB,CAAC,UAAU,CAAC;IACf,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CACtB,KAAgB,EAChB,OAAuB,EACvB,KAAmB,EACb,EAAE;IACR,KAAK,CAAC,GAAG,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;IACxC,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;IACpC,MAAM,aAAa,GAAoB;QACrC,IAAI,EAAE,mBAAmB,CAAC,KAAK,CAAC,UAAU,CAAC;QAC3C,MAAM,EAAE,KAAK,CAAC,OAAO;QACrB,SAAS,EAAE,OAAO,CAAC,EAAE;QACrB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,YAAY;KAC5B,CAAC;IACF,IAAI,gBAAgB,GAClB,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC;QACzD,CAAC,CAAC,KAAK,CAAC,gBAAgB;QACxB,CAAC,CAAC,SAAS,CAAC;IAChB,IAAI,CAAC,gBAAgB,IAAI,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzE,gBAAgB,GAAG,KAAK,CAAC,UAAU,CAAC;IACtC,CAAC;IAED,IAAI,gBAAgB,EAAE,CAAC;QACrB,aAAa,CAAC,UAAU,GAAG,gBAAgB,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;AACrD,CAAC,CAAC;AAEF,MAAM,2BAA2B,GAAG,CAAC,KAAmB,EAAa,EAAE;IACrE,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;QACtB,MAAM,UAAU,CAAC,WAAW,CAAC,GAAG,EAAE,gCAAgC,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,UAAU,CAAC,WAAW,CAC3B,GAAG,EACH,KAAK,CAAC,OAAO,EACb,6BAA6B,CAAC,KAAK,CAAC,UAAU,CAAC,CAChD,CAAC;AACJ,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@ogcio/fastify-error-handler",
+    "version": "4.0.0",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "type": "module",
+    "scripts": {
+        "build": "rm -rf dist tsconfig.prod.tsbuildinfo tsconfig.tsbuildinfo && tsc -p tsconfig.prod.json",
+        "test": "tap --jobs=1 --allow-incomplete-coverage __tests__/**/*.test.ts"
+    },
+    "keywords": [],
+    "author": {
+        "name": "Samuele Salvatico",
+        "email": "samuele.salvatico@nearform.com"
+    },
+    "license": "ISC",
+    "description": "Normalize the error handling of errors with related logs",
+    "dependencies": {
+        "@fastify/sensible": "^5.6.0",
+        "@ogcio/fastify-logging-wrapper": "^4.0.0",
+        "fastify": "^4.28.1"
+    },
+    "devDependencies": {
+        "@types/http-errors": "^2.0.4"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/ogcio/shared-node-utils.git",
+        "directory": "packages/fastify-error-handler"
+    }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import { FastifyInstance } from "fastify";
+import {
+  initializeNotFoundHandler,
+  setupErrorHandler
+} from "./initialize-error-handler.js";
+
+export const initializeErrorHandler = (server: FastifyInstance): void => {
+  setupErrorHandler(server);
+  initializeNotFoundHandler(server);
+};

package/src/initialize-error-handler.ts

@@ -0,0 +1,180 @@
+import {
+  FastifyError,
+  FastifyRequest,
+  FastifyInstance,
+  FastifyReply,
+} from "fastify";
+import { FastifySchemaValidationError } from "fastify/types/schema.js";
+import {
+  setLoggingContext,
+  getLoggingContextError,
+  LogMessages,
+} from "@ogcio/fastify-logging-wrapper";
+import {
+  HttpErrorClasses,
+  ValidationErrorData,
+  parseHttpErrorClass,
+} from "@ogcio/shared-errors";
+import { isHttpError } from "http-errors";
+import { HttpError, httpErrors } from "@fastify/sensible";
+
+export interface OutputHttpError {
+  code: HttpErrorClasses;
+  detail: string;
+  requestId: string;
+  name: string;
+  validation?: ValidationErrorData[];
+  process?: string;
+}
+
+// The error handler below is the same as the original one in Fastify,
+// just without unwanted log entries
+// I've opened an issue to fastify to ask them if we could avoid logging
+// those entries when disableRequestLogging is true
+// https://github.com/fastify/fastify/issues/5409
+export const setupErrorHandler = (server: FastifyInstance): void => {
+  const setErrorHeaders = (
+    error: null | {
+      headers?: { [x: string]: string | number | string[] | undefined };
+      status?: number;
+      statusCode?: number;
+    },
+    reply: FastifyReply
+  ) => {
+    const res = reply.raw;
+    let statusCode = res.statusCode;
+    statusCode = statusCode >= 400 ? statusCode : 500;
+    // treat undefined and null as same
+    if (error != null) {
+      if (error.headers !== undefined) {
+        reply.headers(error.headers);
+      }
+      if (error.status && error.status >= 400) {
+        statusCode = error.status;
+      } else if (error.statusCode && error.statusCode >= 400) {
+        statusCode = error.statusCode;
+      }
+    }
+    res.statusCode = statusCode;
+    reply.statusCode = res.statusCode;
+  };
+
+  server.setErrorHandler(function (error, request, reply) {
+    if (isHttpError(error)) {
+      manageHttpError(error, request, reply);
+      return;
+    }
+    if (error.validation) {
+      const httpError = toOutputHttpValidationError(error);
+      manageHttpError(httpError, request, reply);
+      return;
+    }
+
+    setErrorHeaders(error, reply);
+    reply.send(getResponseFromFastifyError(error, request));
+  });
+};
+
+// The error handler below is the same as the original one in Fastify,
+// just without unwanted log entries
+export const initializeNotFoundHandler = (server: FastifyInstance): void => {
+  server.setNotFoundHandler((request: FastifyRequest, reply: FastifyReply) => {
+    const error = httpErrors.notFound(`Route not found: ${request.url}`);
+    setLoggingContext({
+      error,
+    });
+
+    request.log.error({ error: getLoggingContextError() }, LogMessages.Error);
+    manageHttpError(error, request, reply);
+  });
+};
+
+const getValidationFromFastifyError = (
+  validationInput: FastifySchemaValidationError[]
+): { validation: ValidationErrorData[] } => {
+  const output: ValidationErrorData[] = [];
+
+  for (const input of validationInput) {
+    const key =
+      input.params?.missingProperty ?? input.instancePath.split("/").pop();
+    const message = input.message ?? input.keyword;
+    if (key && typeof key === "string") {
+      output.push({
+        fieldName: key,
+        message,
+        validationRule: input.keyword,
+        additionalInfo: input.params,
+      });
+      continue;
+    }
+
+    output.push({
+      fieldName: input.schemaPath,
+      message,
+      validationRule: input.keyword,
+      additionalInfo: input.params,
+    });
+  }
+
+  return { validation: output };
+};
+
+const getResponseFromFastifyError = (
+  error: FastifyError,
+  request: FastifyRequest
+): OutputHttpError => {
+  const output: OutputHttpError = {
+    code: parseHttpErrorClass(error.statusCode),
+    detail: error.message,
+    requestId: request.id,
+    name: error.name,
+  };
+  if (error.validation && error.validation.length > 0) {
+    output.validation = getValidationFromFastifyError(
+      error.validation
+    ).validation;
+  }
+
+  return output;
+};
+
+const manageHttpError = (
+  error: HttpError,
+  request: FastifyRequest,
+  reply: FastifyReply
+): void => {
+  reply.raw.statusCode = error.statusCode;
+  reply.statusCode = error.statusCode;
+  const errorResponse: OutputHttpError = {
+    code: parseHttpErrorClass(error.statusCode),
+    detail: error.message,
+    requestId: request.id,
+    name: error.name,
+    process: error.errorProcess,
+  };
+  let validationErrors =
+    error.validationErrors && error.validationErrors.length > 0
+      ? error.validationErrors
+      : undefined;
+  if (!validationErrors && error.validation && error.validation.length > 0) {
+    validationErrors = error.validation;
+  }
+
+  if (validationErrors) {
+    errorResponse.validation = validationErrors;
+  }
+
+  reply.status(error.statusCode).send(errorResponse);
+};
+
+const toOutputHttpValidationError = (error: FastifyError): HttpError => {
+  if (!error.validation) {
+    throw httpErrors.createError(500, "This is not a validation error");
+  }
+
+  return httpErrors.createError(
+    422,
+    error.message,
+    getValidationFromFastifyError(error.validation)
+  );
+};

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+      "composite": true,
+      "outDir": "dist",
+      "rootDir": "src"
+    },
+    "include": ["src"],
+    "references": [
+      { "path": "../shared-errors" }
+    ]
+  }

package/tsconfig.prod.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["__tests__", "dist"]
+}