@tsed/platform-log-middleware 8.0.1 → 8.0.3

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/platform-log-middleware",
   "description": "Log request middleware module for Ts.ED Framework (deprecated)",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "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"
@@ -25,19 +26,19 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-middlewares": "8.0.1",
-    "@tsed/platform-params": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/platform-middlewares": "8.0.3",
+    "@tsed/platform-params": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-middlewares": "8.0.1",
-    "@tsed/platform-params": "8.0.1"
+    "@tsed/di": "8.0.3",
+    "@tsed/platform-middlewares": "8.0.3",
+    "@tsed/platform-params": "8.0.3"
   },
   "peerDependenciesMeta": {
     "@tsed/di": {

package/src/domain/PlatformLogMiddlewareSettings.ts

@@ -0,0 +1,26 @@
+export type LoggerRequestFields = ("reqId" | "method" | "url" | "headers" | "body" | "query" | "params" | "duration" | string)[];
+
+export interface PlatformLogMiddlewareSettings {
+  /**
+   * Fields displayed when a request is logged. Possible values: `reqId`, `method`, `url`, `headers`, `body`, `query`,`params`, `duration`.
+   */
+  requestFields?: LoggerRequestFields;
+  /**
+   * Log all incoming request. By default, is true and print the configured `logger.requestFields`.
+   */
+  logRequest?: boolean;
+  /**
+   * Log start of all incoming request. By default, is false
+   */
+  logStart?: boolean;
+  /**
+   * Log end of all incoming request. By default, is true
+   */
+  logEnd?: boolean;
+}
+
+declare global {
+  namespace TsED {
+    interface LoggerConfiguration extends Partial<PlatformLogMiddlewareSettings> {}
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./domain/PlatformLogMiddlewareSettings.js";
+export * from "./middlewares/PlatformLogMiddleware.js";

package/src/middlewares/PlatformLogMiddleware.spec.ts

@@ -0,0 +1,291 @@
+import "../domain/PlatformLogMiddlewareSettings.js";
+
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {PlatformHandlerMetadata} from "@tsed/platform-router";
+
+import {PlatformLogMiddleware} from "./PlatformLogMiddleware.js";
+
+async function createMiddlewareFixture({statusCode = 200, error}: {statusCode?: number; error?: any} = {}) {
+  const middleware = await PlatformTest.invoke<PlatformLogMiddleware>(PlatformLogMiddleware);
+
+  const ctx = PlatformTest.createRequestContext({
+    event: {
+      request: PlatformTest.createRequest({
+        method: "GET",
+        url: "url",
+        originalUrl: undefined
+      }),
+      response: PlatformTest.createResponse({
+        statusCode,
+        error
+      })
+    },
+    endpoint: new Map(),
+    logger: PlatformTest.injector.logger
+  });
+
+  ctx.error = error;
+
+  ctx.handlerMetadata = new PlatformHandlerMetadata({
+    handler: () => {}
+  });
+
+  vi.spyOn(PlatformTest.injector.logger, "info").mockResolvedValue(undefined);
+  vi.spyOn(PlatformTest.injector.logger, "warn").mockResolvedValue(undefined);
+  vi.spyOn(PlatformTest.injector.logger, "trace").mockResolvedValue(undefined);
+  vi.spyOn(PlatformTest.injector.logger, "debug").mockResolvedValue(undefined);
+  vi.spyOn(PlatformTest.injector.logger, "error").mockResolvedValue(undefined);
+
+  ctx.logger.maxStackSize = 0;
+  ctx.data = "test";
+
+  ctx.response.getRes().on = vi.fn();
+
+  return {request: ctx.request.raw, ctx, middleware};
+}
+
+describe("PlatformLogMiddleware", () => {
+  describe("use()", () => {
+    describe("when no debug, logRequest", () => {
+      beforeEach(() =>
+        PlatformTest.create({
+          logger: {
+            debug: false,
+            logRequest: true
+          }
+        })
+      );
+      afterEach(() => PlatformTest.reset());
+      it("should configure request and create context logger", async () => {
+        // GIVEN
+        const {request, ctx, middleware} = await createMiddlewareFixture();
+        request.originalUrl = "/originalUrl";
+        ctx.handlerMetadata.path = "/:id";
+
+        // WHEN
+        middleware.use(ctx);
+
+        // THEN
+        middleware.onLogEnd(request.$ctx);
+
+        // THEN
+        expect(PlatformTest.injector.logger.info).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.start",
+            method: "GET",
+            reqId: "id",
+            url: "/originalUrl",
+            route: "/:id"
+          })
+        );
+        expect(PlatformTest.injector.logger.info).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.end",
+            method: "GET",
+            reqId: "id",
+            url: "/originalUrl",
+            route: "/:id",
+            status: 200,
+            state: "OK"
+          })
+        );
+        expect(PlatformTest.injector.logger.info).toHaveBeenCalledWith(
+          expect.objectContaining({
+            duration: expect.any(Number)
+          })
+        );
+        expect(PlatformTest.injector.logger.info).toHaveBeenCalledWith(expect.objectContaining({time: expect.any(Date)}));
+      });
+    });
+    describe("when debug, logRequest", () => {
+      beforeEach(() =>
+        PlatformTest.create({
+          logger: {
+            level: "debug",
+            logRequest: true
+          }
+        })
+      );
+      afterEach(() => PlatformTest.reset());
+
+      it("should configure request and create context logger (debug, logRequest)", async () => {
+        // GIVEN
+        const {ctx, middleware} = await createMiddlewareFixture();
+
+        // WHEN
+        middleware.use(ctx);
+
+        // THEN
+        middleware.onLogEnd(ctx as any);
+
+        // THEN
+        expect(PlatformTest.injector.logger.debug).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.start",
+            method: "GET",
+            reqId: "id",
+            url: "url"
+          })
+        );
+        expect(PlatformTest.injector.logger.debug).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.end",
+            method: "GET",
+            reqId: "id",
+            url: "url",
+            status: 200,
+            data: "test",
+            state: "OK"
+          })
+        );
+      });
+    });
+    describe("when no debug, logRequest, logEnd", () => {
+      beforeEach(() =>
+        PlatformTest.create({
+          logger: {debug: false, logRequest: true, logEnd: false}
+        })
+      );
+      afterEach(() => PlatformTest.reset());
+      it("should configure request and create context logger ()", async () => {
+        // GIVEN
+        const {request, ctx, middleware} = await createMiddlewareFixture();
+        request.originalUrl = "originalUrl";
+
+        // WHEN
+        middleware.use(ctx);
+
+        // THEN
+        middleware.onLogEnd(request.$ctx as any);
+
+        // THEN
+        expect(PlatformTest.injector.logger.info).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.start"
+          })
+        );
+      });
+    });
+    describe("when no debug, logRequest, logStart", () => {
+      beforeEach(() =>
+        PlatformTest.create({
+          logger: {
+            debug: false,
+            logRequest: true,
+            logStart: false
+          }
+        })
+      );
+      afterEach(() => PlatformTest.reset());
+      it("should configure request and create context logger (no debug, logRequest, logStart)", async () => {
+        // GIVEN
+        const {ctx, middleware} = await createMiddlewareFixture();
+
+        // WHEN
+        middleware.use(ctx);
+
+        // THEN
+        vi.mocked(ctx.response.getRes().on).mock.calls[0][1]();
+        //  middleware.onLogEnd(request.$ctx as any);
+
+        // THEN
+        expect(PlatformTest.injector.logger.info).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.end",
+            method: "GET",
+            reqId: "id",
+            url: "url",
+            status: 200
+          })
+        );
+      });
+      it("should configure request and create context logger (error)", async () => {
+        // GIVEN
+        const {ctx, middleware} = await createMiddlewareFixture({
+          statusCode: 400,
+          error: new Error("Test")
+        });
+
+        // WHEN
+        middleware.use(ctx);
+
+        // THEN
+        vi.mocked(ctx.response.getRes().on).mock.calls[0][1]();
+        //  middleware.onLogEnd(request.$ctx as any);
+
+        // THEN
+        expect(PlatformTest.injector.logger.error).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.end",
+            method: "GET",
+            reqId: "id",
+            url: "url",
+            status: 400,
+            error_name: "Error",
+            error_message: "Test"
+          })
+        );
+      });
+      it("should configure request and create context logger (error.code)", async () => {
+        // GIVEN
+        const error: any = {
+          code: "CODE",
+          message: "message"
+        };
+        const {ctx, middleware} = await createMiddlewareFixture({
+          statusCode: 400,
+          error
+        });
+
+        // WHEN
+        middleware.use(ctx);
+
+        // THEN
+        vi.mocked(ctx.response.getRes().on).mock.calls[0][1]();
+        //  middleware.onLogEnd(request.$ctx as any);
+
+        // THEN
+        expect(PlatformTest.injector.logger.error).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "request.end",
+            method: "GET",
+            reqId: "id",
+            url: "url",
+            status: 400,
+            error_name: "CODE",
+            error_message: "message"
+          })
+        );
+      });
+    });
+    describe("when no debug, log error", () => {
+      beforeEach(() =>
+        PlatformTest.create({
+          logger: {debug: false, logRequest: true}
+        })
+      );
+      afterEach(() => PlatformTest.reset());
+      it("should log error", async () => {
+        // GIVEN
+        const {request, ctx, middleware} = await createMiddlewareFixture();
+        request.originalUrl = "originalUrl";
+        // WHEN
+        middleware.use(ctx);
+
+        // THEN
+        ctx.logger.error({
+          event: "event"
+        });
+        // THEN
+        expect(PlatformTest.injector.logger.error).toHaveBeenCalledWith(
+          expect.objectContaining({
+            event: "event",
+            method: "GET",
+            reqId: "id",
+            url: "originalUrl"
+          })
+        );
+      });
+    });
+  });
+});

package/src/middlewares/PlatformLogMiddleware.ts

@@ -0,0 +1,160 @@
+import {cleanObject} from "@tsed/core";
+import {Constant} from "@tsed/di";
+import {Middleware, MiddlewareMethods} from "@tsed/platform-middlewares";
+import {Context} from "@tsed/platform-params";
+
+import type {LoggerRequestFields} from "../domain/PlatformLogMiddlewareSettings.js";
+
+/**
+ * @middleware
+ * @platform
+ */
+@Middleware()
+export class PlatformLogMiddleware implements MiddlewareMethods {
+  @Constant("logger.requestFields", ["reqId", "method", "url", "duration", "route"])
+  protected requestFields: LoggerRequestFields;
+
+  @Constant("logger.logRequest", true)
+  protected logRequest: boolean;
+
+  @Constant("logger.logStart", true)
+  protected logStart: boolean;
+
+  @Constant("logger.logEnd", true)
+  protected logEnd: boolean;
+
+  @Constant("logger.level")
+  protected logLevel: string;
+
+  get settings() {
+    return this;
+  }
+
+  /**
+   * Handle the request.
+   */
+  public use(@Context() ctx: Context): void {
+    this.configureRequest(ctx);
+    this.onLogStart(ctx);
+
+    ctx.response.onEnd(() => this.onLogEnd(ctx));
+  }
+
+  /**
+   * Called when the `$onResponse` is called by Ts.ED (through Express.end).
+   */
+  onLogEnd(ctx: Context) {
+    const {logRequest, logEnd, logLevel} = this.settings;
+    const started = ctx.logStarted;
+
+    if (logEnd && started) {
+      if (ctx.response.statusCode >= 400) {
+        const error = ctx.error as any | undefined;
+        ctx.logger.error({
+          event: "request.end",
+          status: ctx.response.statusCode,
+          status_code: String(ctx.response.statusCode),
+          state: "KO",
+          ...cleanObject({
+            error_name: error?.name || error?.code,
+            error_message: error?.message,
+            error_errors: error?.errors,
+            error_stack: error?.stack,
+            error_body: error?.body,
+            error_headers: error?.headers
+          })
+        });
+      } else {
+        if (logLevel === "debug") {
+          ctx.logger.debug({
+            event: "request.end",
+            status: ctx.response.statusCode,
+            status_code: String(ctx.response.statusCode),
+            data: ctx.data,
+            state: "OK"
+          });
+        } else if (logRequest) {
+          ctx.logger.info({
+            event: "request.end",
+            status: ctx.response.statusCode,
+            status_code: String(ctx.response.statusCode),
+            state: "OK"
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * The separate onLogStart() function will allow developer to overwrite the initial request log.
+   * @param ctx
+   */
+  protected onLogStart(ctx: Context) {
+    const {logRequest, logLevel, logStart} = this.settings;
+
+    ctx.logStarted = true;
+
+    if (logStart) {
+      if (logLevel === "debug") {
+        ctx.logger.debug({
+          event: "request.start"
+        });
+      } else if (logRequest) {
+        ctx.logger.info({
+          event: "request.start"
+        });
+      }
+    }
+  }
+
+  /**
+   * Attach all information that will be necessary to log the request. Attach a new `request.log` object.
+   */
+  protected configureRequest(ctx: Context) {
+    ctx.logger.alterLog((obj: any, level, withRequest) => {
+      switch (level) {
+        case "info":
+          return {...this.minimalRequestPicker(ctx), ...obj};
+        case "debug":
+          return {...this.requestToObject(ctx), ...obj};
+        default:
+          return {...this.requestToObject(ctx), ...obj};
+      }
+    });
+  }
+
+  /**
+   * Return complete request info.
+   * @returns {Object}
+   * @param ctx
+   */
+  protected requestToObject(ctx: Context): any {
+    const {request} = ctx;
+
+    return {
+      method: request.method,
+      url: request.url,
+      route: request.route || request.url,
+      headers: request.headers,
+      body: request.body,
+      query: request.query,
+      params: request.params
+    };
+  }
+
+  /**
+   * Return a filtered request from global configuration.
+   * @returns {Object}
+   * @param ctx
+   */
+  protected minimalRequestPicker(ctx: Context): any {
+    const {requestFields} = this;
+    const info = this.requestToObject(ctx);
+
+    return requestFields!.reduce((acc: any, key: string) => {
+      acc[key] = info[key];
+
+      return acc;
+    }, {});
+  }
+}