@tsed/platform-log-request 8.0.1 → 8.0.2

package/package.json

@@ -2,16 +2,17 @@
   "name": "@tsed/platform-log-request",
   "description": "Log request module for Ts.ED Framework (Express, Koa, Serverless)",
   "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/cjs/index.js"
+      "default": "./lib/esm/index.js"
     }
   },
   "scripts": {
@@ -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.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/platform-middlewares": "8.0.2",
+    "@tsed/platform-params": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "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.2",
+    "@tsed/platform-middlewares": "8.0.2",
+    "@tsed/platform-params": "8.0.2"
   },
   "peerDependenciesMeta": {
     "@tsed/di": {

package/src/domain/PlatformLogRequestSettings.ts

@@ -0,0 +1,28 @@
+import type {DIContext} from "@tsed/di";
+
+export type AlterLogCallback = (
+  level: "debug" | "info" | "warn" | "error" | "all",
+  obj: Record<string, unknown>,
+  ctx: DIContext
+) => Record<string, unknown>;
+
+export interface PlatformLogRequestSettings {
+  /**
+   * Log all incoming request. By default, is true and print the configured `logger.requestFields`.
+   */
+  logRequest?: boolean;
+  /**
+   * A function to alter the log object before it's logged.
+   */
+  alterLog?: AlterLogCallback;
+  /**
+   * A function to log the server response.
+   */
+  onLogResponse?: ($ctx: DIContext) => void;
+}
+
+declare global {
+  namespace TsED {
+    interface LoggerConfiguration extends Partial<PlatformLogRequestSettings> {}
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./domain/PlatformLogRequestSettings.js";
+export * from "./services/PlatformLogRequestFactory.js";
+export * from "./utils/defaultAlterLog.js";
+export * from "./utils/defaultLogResponse.js";

package/src/services/PlatformLogRequestFactory.spec.ts

@@ -0,0 +1,139 @@
+import "../domain/PlatformLogRequestSettings.js";
+
+import {DITest} from "@tsed/di";
+
+import {PlatformLogRequestFactory} from "./PlatformLogRequestFactory.js";
+
+describe("PlatformLogRequestFactory", () => {
+  describe("when logger is enabled", () => {
+    beforeEach(() =>
+      DITest.create({
+        logger: {}
+      })
+    );
+    afterEach(() => DITest.reset());
+
+    it("should create logger factory", async () => {
+      const factory = await DITest.invoke<PlatformLogRequestFactory>(PlatformLogRequestFactory);
+
+      expect(factory).toEqual({
+        alterLog: expect.any(Function),
+        onLogResponse: expect.any(Function)
+      });
+
+      const ctx: any = {
+        request: {
+          method: "GET"
+        },
+        logger: {
+          alterLog: vi.fn(),
+          info: vi.fn()
+        }
+      };
+
+      vi.spyOn(factory!, "alterLog").mockReturnValue({});
+      vi.spyOn(factory!, "onLogResponse").mockReturnValue(undefined);
+
+      DITest.injector.getProvider(PlatformLogRequestFactory)?.hooks?.$onRequest(factory!, ctx);
+
+      expect(ctx.logger.alterLog).toHaveBeenCalledWith(expect.any(Function));
+
+      ctx.logger.alterLog.mock.calls[0][0]({test: "test"}, "info");
+
+      expect(ctx.logStarted).toBe(true);
+      expect(factory!.alterLog).toHaveBeenCalledWith(
+        "info",
+        {
+          test: "test"
+        },
+        ctx
+      );
+
+      DITest.injector.getProvider(PlatformLogRequestFactory)?.hooks?.$onResponse(factory!, ctx);
+
+      expect(factory!.onLogResponse).toHaveBeenCalledWith(ctx);
+    });
+  });
+  describe("when logger is enabled with options", () => {
+    beforeEach(() =>
+      DITest.create({
+        logger: {
+          logRequest: true,
+          alterLog: vi.fn().mockReturnValue({}),
+          onLogResponse: vi.fn()
+        }
+      })
+    );
+    afterEach(() => DITest.reset());
+
+    it("should create logger factory", async () => {
+      const factory = await DITest.invoke<PlatformLogRequestFactory>(PlatformLogRequestFactory);
+
+      expect(factory).toEqual({
+        alterLog: expect.any(Function),
+        onLogResponse: expect.any(Function)
+      });
+
+      const ctx: any = {
+        request: {
+          method: "GET"
+        },
+        logger: {
+          alterLog: vi.fn(),
+          info: vi.fn()
+        }
+      };
+
+      DITest.injector.getProvider(PlatformLogRequestFactory)?.hooks?.$onRequest(factory!, ctx);
+
+      expect(ctx.logger.alterLog).toHaveBeenCalledWith(expect.any(Function));
+
+      ctx.logger.alterLog.mock.calls[0][0]({test: "test"}, "info");
+
+      expect(ctx.logStarted).toBe(true);
+      expect(factory!.alterLog).toHaveBeenCalledWith(
+        "info",
+        {
+          test: "test"
+        },
+        ctx
+      );
+
+      DITest.injector.getProvider(PlatformLogRequestFactory)?.hooks?.$onResponse(factory!, ctx);
+
+      expect(factory!.onLogResponse).toHaveBeenCalledWith(ctx);
+    });
+  });
+  describe("when logger is disabled", () => {
+    beforeEach(() =>
+      DITest.create({
+        logger: {
+          logRequest: false
+        }
+      })
+    );
+    afterEach(() => DITest.reset());
+
+    it("should create logger factory", async () => {
+      const factory = await DITest.invoke<PlatformLogRequestFactory>(PlatformLogRequestFactory);
+
+      expect(factory).toEqual(null);
+
+      const ctx: any = {
+        request: {
+          method: "GET"
+        },
+        logger: {
+          alterLog: vi.fn(),
+          info: vi.fn()
+        }
+      };
+
+      DITest.injector.getProvider(PlatformLogRequestFactory)?.hooks?.$onRequest(factory!, ctx);
+
+      expect(ctx.logger.alterLog).not.toHaveBeenCalled();
+
+      DITest.injector.getProvider(PlatformLogRequestFactory)?.hooks?.$onResponse(factory!, ctx);
+    });
+  });
+});

package/src/services/PlatformLogRequestFactory.ts

@@ -0,0 +1,38 @@
+import {type BaseContext, constant, injectable} from "@tsed/di";
+
+import {defaultAlterLog} from "../utils/defaultAlterLog.js";
+import {defaultLogResponse} from "../utils/defaultLogResponse.js";
+
+function factory() {
+  const {
+    logRequest = true,
+    alterLog = defaultAlterLog,
+    onLogResponse = defaultLogResponse
+  } = constant<TsED.LoggerConfiguration>("logger", {});
+
+  return logRequest
+    ? {
+        alterLog,
+        onLogResponse
+      }
+    : null;
+}
+
+export type PlatformLogRequestFactory = ReturnType<typeof factory>;
+
+export const PlatformLogRequestFactory = injectable(Symbol.for("PLATFORM:LOGGER:REQUEST"))
+  .factory(factory)
+  .hooks({
+    $onRequest(instance: ReturnType<typeof factory>, $ctx: BaseContext) {
+      if (instance) {
+        $ctx.logger.alterLog((obj: any, level) => instance.alterLog(level, obj, $ctx));
+        $ctx.logStarted = true;
+      }
+    },
+    $onResponse(instance: ReturnType<typeof factory>, $ctx: BaseContext) {
+      if (instance && $ctx.logStarted) {
+        instance.onLogResponse($ctx);
+      }
+    }
+  })
+  .token();

package/src/utils/defaultAlterLog.spec.ts

@@ -0,0 +1,66 @@
+import {defaultAlterLog} from "./defaultAlterLog.js";
+
+describe("defaultAlterLog", () => {
+  it("should return the expected log object", () => {
+    expect(
+      defaultAlterLog("info", {test: "test"}, {
+        request: {
+          method: "GET",
+          url: "url",
+          headers: {
+            "x-forwarded-for": "value"
+          },
+          route: "route"
+        }
+      } as never)
+    ).toEqual({
+      method: "GET",
+      route: "route",
+      test: "test",
+      url: "url"
+    });
+  });
+  it("should return the expected log object (without route)", () => {
+    expect(
+      defaultAlterLog("info", {test: "test"}, {
+        request: {
+          method: "GET",
+          url: "url",
+          headers: {
+            "x-forwarded-for": "value"
+          }
+        }
+      } as never)
+    ).toEqual({
+      method: "GET",
+      route: "url",
+      test: "test",
+      url: "url"
+    });
+  });
+  it("should return the expected log object with extras info", () => {
+    expect(
+      defaultAlterLog("error", {test: "test"}, {
+        request: {
+          method: "GET",
+          url: "url",
+          headers: {
+            "x-forwarded-for": "value"
+          },
+          route: "route"
+        }
+      } as never)
+    ).toEqual({
+      method: "GET",
+      route: "route",
+      test: "test",
+      url: "url",
+      body: undefined,
+      headers: {
+        "x-forwarded-for": "value"
+      },
+      params: undefined,
+      query: undefined
+    });
+  });
+});

package/src/utils/defaultAlterLog.ts

@@ -0,0 +1,22 @@
+import type {DIContext} from "@tsed/di";
+
+export function defaultAlterLog(level: string, obj: Record<string, unknown>, ctx: DIContext) {
+  const minimalLog = {
+    method: ctx.request.method,
+    url: ctx.request.url,
+    route: ctx.request.route || ctx.request.url,
+    ...obj
+  };
+
+  if (level === "info") {
+    return minimalLog;
+  }
+
+  return {
+    ...minimalLog,
+    headers: ctx.request.headers,
+    body: ctx.request.body,
+    query: ctx.request.query,
+    params: ctx.request.params
+  };
+}

package/src/utils/defaultLogResponse.spec.ts

@@ -0,0 +1,98 @@
+import {defaultLogResponse} from "./defaultLogResponse.js";
+
+describe("defaultLogEnd", () => {
+  it("should log the request end", () => {
+    // GIVEN
+    const $ctx = {
+      response: {
+        statusCode: 200
+      },
+      logger: {
+        info: vi.fn()
+      }
+    };
+
+    // WHEN
+    defaultLogResponse($ctx as any);
+
+    // THEN
+    expect($ctx.logger.info).toHaveBeenCalledWith({
+      event: "request.end",
+      status: 200,
+      status_code: "200",
+      state: "OK"
+    });
+  });
+  it("should log the request end with error", () => {
+    // GIVEN
+    const $ctx = {
+      response: {
+        statusCode: 500
+      },
+      error: {
+        name: "name",
+        message: "message",
+        errors: "errors",
+        stack: "stack",
+        body: "body",
+        headers: "headers"
+      },
+      logger: {
+        error: vi.fn()
+      }
+    };
+
+    // WHEN
+    defaultLogResponse($ctx as any);
+
+    // THEN
+    expect($ctx.logger.error).toHaveBeenCalledWith({
+      event: "request.end",
+      status: 500,
+      status_code: "500",
+      state: "KO",
+      error_name: "name",
+      error_message: "message",
+      error_errors: "errors",
+      error_stack: "stack",
+      error_body: "body",
+      error_headers: "headers"
+    });
+  });
+  it("should log the request end with error code", () => {
+    // GIVEN
+    const $ctx = {
+      response: {
+        statusCode: 500
+      },
+      error: {
+        code: "code",
+        message: "message",
+        errors: "errors",
+        stack: "stack",
+        body: "body",
+        headers: "headers"
+      },
+      logger: {
+        error: vi.fn()
+      }
+    };
+
+    // WHEN
+    defaultLogResponse($ctx as any);
+
+    // THEN
+    expect($ctx.logger.error).toHaveBeenCalledWith({
+      event: "request.end",
+      status: 500,
+      status_code: "500",
+      state: "KO",
+      error_name: "code",
+      error_message: "message",
+      error_errors: "errors",
+      error_stack: "stack",
+      error_body: "body",
+      error_headers: "headers"
+    });
+  });
+});

package/src/utils/defaultLogResponse.ts

@@ -0,0 +1,30 @@
+import {cleanObject} from "@tsed/core";
+import type {BaseContext} from "@tsed/di";
+
+export function defaultLogResponse($ctx: BaseContext) {
+  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 {
+    $ctx.logger.info({
+      event: "request.end",
+      status: $ctx.response.statusCode,
+      status_code: String($ctx.response.statusCode),
+      state: "OK"
+    });
+  }
+}