feat: sdk logger wrapper (#7276)

Author: dawid-ziobro

.changeset/fuzzy-pugs-greet.md

@@ -0,0 +1,5 @@
+---
+"@vue-storefront/sdk": patch
+---
+
+rc.1

packages/sdk/src/__tests__/integration/modules/loggerModule.spec.ts

@@ -2,6 +2,7 @@ import { LoggerFactory } from "@vue-storefront/logger";
 import { buildModule } from "../../../modules/buildModule";
 import { initSDK } from "../../../bootstrap";
 import { loggerModule } from "../../../modules/loggerModule";
+import type { LoggerInterface } from "../../../modules/loggerModule/types";
 
 describe("loggerModule", () => {
   it("should be able to be used as standard SDK module", async () => {
@@ -24,7 +25,6 @@ describe("loggerModule", () => {
     "should have a function '%s' available within the logger",
     (functionName) => {
       const sdkConfig = { logger: buildModule(loggerModule) };
-
       const sdk = initSDK(sdkConfig);
 
       expect(
@@ -41,23 +41,12 @@ describe("loggerModule", () => {
 
   it("should be able to pass custom handler", async () => {
     const mock = jest.fn();
-    const customLogger = {
-      log: mock,
-      emergency: mock,
-      alert: mock,
-      critical: mock,
-      error: mock,
-      warning: mock,
-      notice: mock,
-      info: mock,
-      debug: mock,
-    };
+    const handler = { info: mock } as unknown as LoggerInterface;
     const sdkConfig = {
       logger: buildModule(loggerModule, {
-        handler: customLogger,
+        handler,
       }),
     };
-
     const sdk = initSDK(sdkConfig);
 
     await sdk.logger.info("foo");
@@ -73,4 +62,16 @@ describe("loggerModule", () => {
 
     expect(createSpy).toHaveBeenCalled();
   });
+
+  it("should warn about wrong configuration", async () => {
+    const consoleSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+
+    loggerModule({
+      handler: {} as unknown as LoggerInterface,
+      foo: "bar",
+    });
+
+    expect(consoleSpy).toHaveBeenCalled();
+    consoleSpy.mockReset();
+  });
 });

packages/sdk/src/__tests__/unit/loggerModule/injectMetadata.spec.ts

@@ -0,0 +1,14 @@
+import { injectMetadata } from "../../../modules/loggerModule/injectMetadata";
+import type { LoggerInterface } from "../../../modules/loggerModule/types";
+
+describe("loggerModule injectMetadata", () => {
+  it("should return logger with injected metadata", () => {
+    const mock = jest.fn();
+    const logger = { info: mock } as unknown as LoggerInterface;
+    const loggerWithMetadata = injectMetadata(logger, { foo: "bar" });
+
+    loggerWithMetadata.info("test message");
+
+    expect(mock).toHaveBeenCalledWith("test message", { foo: "bar" });
+  });
+});

packages/sdk/src/__tests__/unit/loggerModule/utils.spec.ts

@@ -0,0 +1,26 @@
+import {
+  isEmptyObject,
+  isInvalidConfig,
+} from "../../../modules/loggerModule/utils";
+import type { LoggerInterface } from "../../../modules/loggerModule/types";
+
+describe("loggerModule utils", () => {
+  it("should verify if object is empty", () => {
+    expect(isEmptyObject()).toBe(true);
+    expect(isEmptyObject({})).toBe(true);
+    expect(isEmptyObject({ foo: "bar" })).toBe(false);
+  });
+
+  it("should verify if config is invalid", () => {
+    expect(isInvalidConfig()).toBe(false);
+    expect(isInvalidConfig({})).toBe(false);
+    expect(isInvalidConfig({ foo: "bar" })).toBe(false);
+    expect(isInvalidConfig({ handler: {} as LoggerInterface })).toBe(false);
+    expect(
+      isInvalidConfig({
+        handler: {} as unknown as LoggerInterface,
+        foo: "bar",
+      })
+    ).toBe(true);
+  });
+});

packages/sdk/src/modules/loggerModule/index.ts

@@ -1,14 +1,32 @@
 import { LoggerFactory, LoggerType } from "@vue-storefront/logger";
 import type { Module } from "../../types";
 import type { LoggerModuleConfig } from "./types";
+import { injectMetadata } from "./injectMetadata";
+import { isInvalidConfig } from "./utils";
 
 export const loggerModule = (options?: LoggerModuleConfig) => {
   const logger =
     options?.handler ?? LoggerFactory.create(LoggerType.ConsolaGcp, options);
 
+  if (isInvalidConfig(options)) {
+    console.warn(
+      `Both 'handler' and other config options are provided to logger's configuration.
+      In such case 'handler' will be used and other options will be ignored as those are
+      supported only by the built-in logger.
+      If you want to use other options, please remove 'handler' from the configuration.
+      If you want to use your handler, please remove other options from the configuration.`
+    );
+  }
+
+  const loggerWithMetadata = injectMetadata(logger, {
+    alokai: {
+      context: "storefront",
+    },
+  });
+
   return {
     connector: {
-      ...logger,
+      ...loggerWithMetadata,
     },
   } satisfies Module;
 };

packages/sdk/src/modules/loggerModule/injectMetadata.ts

@@ -0,0 +1,22 @@
+import type { LoggerInterface } from "./types";
+
+export function injectMetadata(
+  logger: LoggerInterface,
+  externalData: Record<string, any>
+): LoggerInterface {
+  return new Proxy(logger, {
+    get(target, prop) {
+      const targetProp = target[prop as keyof LoggerInterface];
+      if (typeof targetProp === "function") {
+        return (...args: Parameters<typeof targetProp>[]) => {
+          const [logData, metadata] = args;
+          targetProp(logData, {
+            ...metadata,
+            ...externalData,
+          });
+        };
+      }
+      return targetProp;
+    },
+  });
+}

packages/sdk/src/modules/loggerModule/types.ts

@@ -11,7 +11,6 @@ type LogLevel =
   | "debug";
 
 export interface LoggerInterface {
-  log(level: LogLevel, logData: LogData, metadata?: Metadata): void;
   emergency(logData: LogData, metadata?: Metadata): void;
   alert(logData: LogData, metadata?: Metadata): void;
   critical(logData: LogData, metadata?: Metadata): void;

packages/sdk/src/modules/loggerModule/utils.ts

@@ -0,0 +1,18 @@
+import type { LoggerModuleConfig } from "./types";
+
+export const isEmptyObject = (obj = {}) => {
+  return Object.keys(obj).length === 0;
+};
+
+/**
+ * Check if the config is invalid. Invalid config is considered when both handler and other options are provided,
+ * then handler will be used and other options will be ignored.
+ * @param config
+ */
+export const isInvalidConfig = (config?: LoggerModuleConfig) => {
+  if (config) {
+    const { handler, ...rest } = config;
+    return !!handler && !isEmptyObject(rest);
+  }
+  return false;
+};