chore: Simplify logger service

src/__mocks__/logger-mock-impl.ts

@@ -1,7 +1,7 @@
-import { BaseLogger } from '../adapters/logger';
+import { Logger } from "../interfaces";
 
 export const log = jest.fn();
 
-export class LoggerMockImpl extends BaseLogger {
+export class LoggerMockImpl implements Logger {
   log = log;
 }

src/adapters/clients.ts

@@ -1,3 +1,4 @@
+import { type LogType } from "../interfaces";
 import { type mastodon } from "../mastodon";
 import {
   createActionProxy,
@@ -11,7 +12,7 @@ import {
   type WebSocketConfigProps,
 } from "./config";
 import { HttpNativeImpl } from "./http";
-import { createLogger, type LogType } from "./logger";
+import { createLogger } from "./logger";
 import { SerializerNativeImpl } from "./serializers";
 import { WebSocketConnectorImpl } from "./ws";
 

src/adapters/http/http-native-impl.ts

@@ -28,8 +28,8 @@ export class HttpNativeImpl extends BaseHttp implements Http {
     const request = this.createRequest(params);
 
     try {
-      this.logger?.info(`↑ ${request.method} ${request.url}`);
-      this.logger?.debug("\tbody", {
+      this.logger?.log("info", `↑ ${request.method} ${request.url}`);
+      this.logger?.log("debug", "\tbody", {
         encoding: params.encoding,
         body: params.body,
       });
@@ -47,15 +47,15 @@ export class HttpNativeImpl extends BaseHttp implements Http {
       }
 
       const data = this.serializer.deserialize(encoding, text);
-      this.logger?.info(`↓ ${request.method} ${request.url}`);
-      this.logger?.debug("\tbody", text);
+      this.logger?.log("info", `↓ ${request.method} ${request.url}`);
+      this.logger?.log("debug", "\tbody", text);
 
       return {
         headers: response.headers,
         data,
       };
     } catch (error) {
-      this.logger?.debug(`HTTP failed`, error);
+      this.logger?.log("debug", `HTTP failed`, error);
       throw await this.createError(error);
     }
   }

src/adapters/logger/factory.ts

@@ -1,4 +1,5 @@
-import { LogLevel, type LogType } from "./log-level";
+import { type LogType } from "../../interfaces";
+import { LogLevel } from "./log-level";
 import { LoggerConsoleImpl } from "./logger-console-impl";
 
 export const createLogger = (type?: LogType): LoggerConsoleImpl => {

src/adapters/logger/index.ts

@@ -1,4 +1,3 @@
-export * from "./base-logger";
 export * from "./logger-console-impl";
 export * from "./log-level";
 export * from "./factory";

src/adapters/logger/log-level.ts

@@ -1,3 +1,5 @@
+import { type LogType } from "../../interfaces";
+
 /* eslint-disable unicorn/prefer-math-trunc */
 const LOG_TYPES = Object.freeze({
   DEBUG: 1 << 0,
@@ -6,8 +8,6 @@ const LOG_TYPES = Object.freeze({
   ERROR: 1 << 3,
 });
 
-export type LogType = "debug" | "info" | "warn" | "error";
-
 export class LogLevel {
   private constructor(private readonly level: number) {}
 

src/adapters/logger/logger-console-impl.spec.ts

@@ -9,28 +9,28 @@ describe("LoggerConsoleImpl", () => {
   it("logs debug", () => {
     const consoleDebug = jest.spyOn(console, "debug").mockImplementation();
     const logger = new LoggerConsoleImpl(LogLevel.from("debug"));
-    logger.debug("message", { meta: "meta" });
+    logger.log("debug", "message", { meta: "meta" });
     expect(consoleDebug).toHaveBeenCalledWith("message", { meta: "meta" });
   });
 
   it("logs info", () => {
     const consoleInfo = jest.spyOn(console, "info").mockImplementation();
     const logger = new LoggerConsoleImpl(LogLevel.from("info"));
-    logger.info("message", { meta: "meta" });
+    logger.log("info", "message", { meta: "meta" });
     expect(consoleInfo).toHaveBeenCalledWith("message", { meta: "meta" });
   });
 
   it("logs warn", () => {
     const consoleWarn = jest.spyOn(console, "warn").mockImplementation();
     const logger = new LoggerConsoleImpl(LogLevel.from("warn"));
-    logger.warn("message", { meta: "meta" });
+    logger.log("warn", "message", { meta: "meta" });
     expect(consoleWarn).toHaveBeenCalledWith("message", { meta: "meta" });
   });
 
   it("logs error", () => {
     const consoleError = jest.spyOn(console, "error").mockImplementation();
     const logger = new LoggerConsoleImpl(LogLevel.from("error"));
-    logger.error("message", { meta: "meta" });
+    logger.log("error", "message", { meta: "meta" });
     expect(consoleError).toHaveBeenCalledWith("message", { meta: "meta" });
   });
 });

src/adapters/logger/logger-console-impl.ts

@@ -1,10 +1,15 @@
 /* eslint-disable no-console */
-import { type Logger } from "../../interfaces";
-import { BaseLogger } from "./base-logger";
-import { type LogType } from "./log-level";
+import { type Logger, type LogType } from "../../interfaces";
+import { type LogLevel } from "./log-level";
+
+export class LoggerConsoleImpl implements Logger {
+  constructor(private readonly level: LogLevel) {}
 
-export class LoggerConsoleImpl extends BaseLogger implements Logger {
   log(type: LogType, message: string, meta: unknown): void {
+    if (!this.level.satisfies(type)) {
+      return;
+    }
+
     const args = meta == undefined ? [message] : [message, meta];
     switch (type) {
       case "debug": {

src/adapters/ws/web-socket-connector.ts

@@ -72,26 +72,26 @@ export class WebSocketConnectorImpl implements WebSocketConnector {
       this.ws?.close();
 
       try {
-        this.logger?.info("Connecting to WebSocket...");
+        this.logger?.log("info", "Connecting to WebSocket...");
         {
           const ctor = (this.props.implementation ??
             WebSocket) as typeof WebSocket;
           const ws = new ctor(...this.props.constructorParameters);
           await waitForOpen(ws);
           this.ws = ws;
         }
-        this.logger?.info("Connected to WebSocket");
+        this.logger?.log("info", "Connected to WebSocket");
 
         for (const { resolve } of this.queue) {
           resolve(this.ws);
         }
         this.queue = [];
 
         await waitForClose(this.ws);
-        this.logger?.info("WebSocket closed");
+        this.logger?.log("info", "WebSocket closed");
         this.backoff.clear();
       } catch (error) {
-        this.logger?.error("WebSocket error:", error);
+        this.logger?.log("error", "WebSocket error:", error);
       }
 
       if (this.disableRetry) {

src/adapters/ws/web-socket-subscription.ts

@@ -21,7 +21,7 @@ export class WebSocketSubscription implements mastodon.streaming.Subscription {
   ) {}
 
   async *values(): AsyncIterableIterator<mastodon.streaming.Event> {
-    this.logger?.info("Subscribing to stream", this.stream);
+    this.logger?.log("info", "Subscribing to stream", this.stream);
 
     while (this.connector.canAcquire()) {
       this.connection = await this.connector.acquire();
@@ -34,12 +34,12 @@ export class WebSocketSubscription implements mastodon.streaming.Subscription {
         ...this.params,
       });
 
-      this.logger?.debug("↑ WEBSOCKET", data);
+      this.logger?.log("debug", "↑ WEBSOCKET", data);
       this.connection.send(data);
 
       for await (const event of this.transformIntoEvents(messages)) {
         if (!this.matches(event)) continue;
-        this.logger?.debug("↓ WEBSOCKET", event);
+        this.logger?.log("debug", "↓ WEBSOCKET", event);
         yield event;
       }
     }

src/interfaces/logger.ts

@@ -1,6 +1,5 @@
+export type LogType = "debug" | "info" | "warn" | "error";
+
 export interface Logger {
-  debug(message: string, meta?: unknown): void;
-  info(message: string, meta?: unknown): void;
-  warn(message: string, meta?: unknown): void;
-  error(message: string, meta?: unknown): void;
+  log(type: LogType, message: string, meta?: unknown): void;
 }