feat: logger

.eslintrc.js

@@ -1,3 +1,6 @@
 module.exports = {
   extends: "@vue-storefront/eslint-config-integrations",
+  rules: {
+    "class-methods-use-this": "off",
+  },
 };

.gitignore

@@ -40,5 +40,5 @@ coverage
 # Local version of changeset's changelog
 .changeset/changelog.js
 
+# Turbo files
 .turbo
-.cache_ggshield

packages/logger/__tests__/unit/consolaStructuredLogger.spec.ts

@@ -0,0 +1,119 @@
+import { ConsolaStructuredLogger } from "../../src/ConsolaStructuredLogger";
+import { LogLevel } from "../../src/interfaces/LogLevel";
+import { StructuredLog } from "../../src/interfaces/StructuredLog";
+
+describe("ConsolaStructuredLogger", () => {
+  let logger: ConsolaStructuredLogger;
+  let structuredLog: StructuredLog;
+
+  beforeEach(() => {
+    structuredLog = {
+      createLog: jest.fn(),
+    };
+    logger = new ConsolaStructuredLogger(structuredLog);
+  });
+
+  it("should create a ConsolaStructuredLogger instance", () => {
+    expect(logger).toBeInstanceOf(ConsolaStructuredLogger);
+  });
+
+  it("should log structured data at the specified level", () => {
+    const logData = { message: "test message" };
+    const level = LogLevel.Info;
+
+    logger.logStructured = jest.fn();
+
+    logger.log(level, logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(level, logData);
+  });
+
+  it("should log at the emergency level", () => {
+    const logData = "emergency log";
+
+    logger.logStructured = jest.fn();
+
+    logger.emergency(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(
+      LogLevel.Emergency,
+      logData
+    );
+  });
+
+  it("should log at the alert level", () => {
+    const logData = "alert log";
+
+    logger.logStructured = jest.fn();
+
+    logger.alert(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(LogLevel.Alert, logData);
+  });
+
+  it("should log at the critical level", () => {
+    const logData = "critical log";
+
+    logger.logStructured = jest.fn();
+
+    logger.critical(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(
+      LogLevel.Critical,
+      logData
+    );
+  });
+
+  it("should log at the error level", () => {
+    const logData = "error log";
+
+    logger.logStructured = jest.fn();
+
+    logger.error(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(LogLevel.Error, logData);
+  });
+
+  it("should log at the warning level", () => {
+    const logData = "warning log";
+
+    logger.logStructured = jest.fn();
+
+    logger.warning(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(
+      LogLevel.Warning,
+      logData
+    );
+  });
+
+  it("should log at the notice level", () => {
+    const logData = "notice log";
+
+    logger.logStructured = jest.fn();
+
+    logger.notice(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(LogLevel.Notice, logData);
+  });
+
+  it("should log at the info level", () => {
+    const logData = "info log";
+
+    logger.logStructured = jest.fn();
+
+    logger.info(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(LogLevel.Info, logData);
+  });
+
+  it("should log at the debug level", () => {
+    const logData = "debug log";
+
+    logger.logStructured = jest.fn();
+
+    logger.debug(logData);
+
+    expect(logger.logStructured).toHaveBeenCalledWith(LogLevel.Debug, logData);
+  });
+});

packages/logger/__tests__/unit/loggerFactory.spec.ts

@@ -0,0 +1,21 @@
+import { LoggerFactory } from "../../src/LoggerFactory";
+
+describe("LoggerFactory try to create type '$type'", () => {
+  // We can add more in the future
+  it.each([
+    {
+      type: "consola-gcp",
+      expected: "ConsolaStructuredLogger",
+    },
+  ])("should create a $type logger", ({ type, expected }) => {
+    const result = LoggerFactory.create(type as any);
+    expect(result.constructor.name).toBe(expected);
+  });
+
+  it(`should throw an error for unknown logger type`, () => {
+    const unknownLoggerType = "some-unknown-logger";
+    expect(() =>
+      LoggerFactory.create(unknownLoggerType as any, {})
+    ).toThrowError(`Logger type ${unknownLoggerType} is not supported`);
+  });
+});

packages/logger/__tests__/unit/structuredLog/gcpStructuredLog.spec.ts

@@ -0,0 +1,80 @@
+import { LogLevel } from "../../../src/interfaces/LogLevel";
+import { GCPStructuredLog } from "../../../src/structuredLog/GCPStructuredLog";
+
+describe("GCPStructuredLog", () => {
+  it.each([
+    {
+      logData: "test message",
+      options: {},
+      severity: LogLevel.Alert,
+      expected: {
+        message: "test message",
+        severity: "ALERT",
+        timestamp: expect.any(String),
+        trace: undefined,
+      },
+    },
+    {
+      logData: { message: "test message" },
+      options: { includeStackTrace: true },
+      severity: undefined,
+      expected: {
+        message: '{"message":"test message"}',
+        severity: "DEFAULT",
+        timestamp: expect.any(String),
+        trace: undefined,
+      },
+    },
+    {
+      logData: new Error("test error"),
+      options: { includeStackTrace: true },
+      severity: undefined,
+      expected: {
+        message: "test error",
+        severity: "DEFAULT",
+        timestamp: expect.any(String),
+        trace: expect.any(String),
+      },
+    },
+    {
+      logData: "another test message",
+      options: { includeStackTrace: false },
+      severity: LogLevel.Info,
+      expected: {
+        message: "another test message",
+        severity: "INFO",
+        timestamp: expect.any(String),
+        trace: undefined,
+      },
+    },
+    {
+      logData: { message: "test message with options" },
+      options: { includeStackTrace: false },
+      severity: LogLevel.Debug,
+      expected: {
+        message: '{"message":"test message with options"}',
+        severity: "DEBUG",
+        timestamp: expect.any(String),
+        trace: undefined,
+      },
+    },
+    {
+      logData: new Error("another test error"),
+      options: { includeStackTrace: true },
+      severity: LogLevel.Error,
+      expected: {
+        message: "another test error",
+        severity: "ERROR",
+        timestamp: expect.any(String),
+        trace: expect.any(String),
+      },
+    },
+  ])(
+    "should create a GCP structured log",
+    ({ logData, expected, options, severity }) => {
+      const log = new GCPStructuredLog();
+      const gcpStructuredLog = log.createLog(logData, options, severity as any);
+      expect(gcpStructuredLog).toEqual(expected);
+    }
+  );
+});

packages/logger/jest.config.ts

@@ -0,0 +1,5 @@
+import { baseConfig } from "@vue-storefront/jest-config";
+
+export default {
+  ...baseConfig,
+};

packages/logger/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@vue-storefront/logger",
+  "version": "1.0.0",
+  "main": "lib/index.cjs.js",
+  "module": "lib/index.es.js",
+  "types": "lib/index.d.ts",
+  "license": "MIT",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "build": "rimraf lib && rollup -c",
+    "test": "yarn test:unit && yarn test:integration",
+    "test:unit": "jest -c jest.config.ts --coverage",
+    "test:integration": "echo 'No integration tests available'",
+    "lint": "eslint . --ext .ts,.js",
+    "prepublishOnly": "yarn build",
+    "changesets:version": "yarn changeset version && YARN_ENABLE_IMMUTABLE_INSTALLS=false yarn install",
+    "changesets:publish": "yarn build && yarn changeset publish"
+  },
+  "packageManager": "[email protected]",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "consola": "^3"
+  }
+}

packages/logger/rollup.config.js

@@ -0,0 +1,4 @@
+import { generateBaseConfig } from "@vue-storefront/rollup-config";
+import package_ from "./package.json";
+
+export default [generateBaseConfig(package_)];