refactor: enforce logger naming and no-console

Author: Priyanshubhartistm

biome.json

@@ -24,9 +24,24 @@
 			"recommended": false,
 			"correctness": { "noUnusedVariables": "error" },
 			"style": { "useBlockStatements": "warn" },
-			"suspicious": { "noExplicitAny": "off" }
+			"suspicious": {
+				"noExplicitAny": "off",
+				"noConsole": "error"
+			}
 		}
 	},
+	"overrides": [
+		{
+			"includes": ["migrations/**", "src/clean-db.ts", "src/import-events.ts", "src/scripts/**", "test/**"],
+			"linter": {
+				"rules": {
+					"suspicious": {
+						"noConsole": "off"
+					}
+				}
+			}
+		}
+	],
 	"javascript": {
 		"formatter": {
 			"quoteStyle": "single",

src/adapters/redis-adapter.ts

@@ -2,7 +2,7 @@ import { CacheClient } from '../@types/cache'
 import { createLogger } from '../factories/logger-factory'
 import { ICacheAdapter } from '../@types/adapters'
 
-const debug = createLogger('redis-adapter')
+const logger = createLogger('redis-adapter')
 
 export class RedisAdapter implements ICacheAdapter {
   private connection: Promise<void>
@@ -13,11 +13,11 @@ export class RedisAdapter implements ICacheAdapter {
     this.connection.catch((error) => this.onClientError(error))
 
     this.client
-      .on('connect', () => debug('connecting'))
-      .on('ready', () => debug('connected'))
+      .on('connect', () => logger('connecting'))
+      .on('ready', () => logger('connected'))
       .on('error', (error) => this.onClientError(error))
       .on('reconnecting', () => {
-        debug('reconnecting')
+        logger('reconnecting')
         this.connection = new Promise((resolve, reject) => {
           const cleanup = () => {
             this.client.removeListener('ready', onReady)
@@ -42,25 +42,25 @@ export class RedisAdapter implements ICacheAdapter {
   }
 
   private onClientError(error: Error) {
-    debug.error('Unable to connect to Redis.', error)
+    logger.error('Unable to connect to Redis.', error)
     // throw error
   }
 
   public async hasKey(key: string): Promise<boolean> {
     await this.connection
-    debug('has %s key', key)
+    logger('has %s key', key)
     return Boolean(this.client.exists(key))
   }
 
   public async getKey(key: string): Promise<string> {
     await this.connection
-    debug('get %s key', key)
+    logger('get %s key', key)
     return this.client.get(key)
   }
 
   public async setKey(key: string, value: string, expirySeconds?: number): Promise<boolean> {
     await this.connection
-    debug('set %s key', key)
+    logger('set %s key', key)
     if (typeof expirySeconds === 'number') {
       return 'OK' === (await this.client.set(key, value, { EX: expirySeconds }))
     }
@@ -69,25 +69,25 @@ export class RedisAdapter implements ICacheAdapter {
 
   public async removeRangeByScoreFromSortedSet(key: string, min: number, max: number): Promise<number> {
     await this.connection
-    debug('remove %d..%d range from sorted set %s', min, max, key)
+    logger('remove %d..%d range from sorted set %s', min, max, key)
     return this.client.zRemRangeByScore(key, min, max)
   }
 
   public async getRangeFromSortedSet(key: string, min: number, max: number): Promise<string[]> {
     await this.connection
-    debug('get %d..%d range from sorted set %s', min, max, key)
+    logger('get %d..%d range from sorted set %s', min, max, key)
     return this.client.zRange(key, min, max)
   }
 
   public async setKeyExpiry(key: string, expiry: number): Promise<void> {
     await this.connection
-    debug('expire at %d from sorted set %s', expiry, key)
+    logger('expire at %d from sorted set %s', expiry, key)
     await this.client.expire(key, expiry)
   }
 
   public async addToSortedSet(key: string, set: Record<string, string>): Promise<number> {
     await this.connection
-    debug('add %o to sorted set %s', set, key)
+    logger('add %o to sorted set %s', set, key)
     const members = Object.entries(set).map(([value, score]) => ({ score: Number(score), value }))
 
     return this.client.zAdd(key, members)

src/adapters/web-server-adapter.ts

@@ -4,11 +4,11 @@ import { Server } from 'http'
 import { createLogger } from '../factories/logger-factory'
 import { IWebServerAdapter } from '../@types/adapters'
 
-const debug = createLogger('web-server-adapter')
+const logger = createLogger('web-server-adapter')
 
 export class WebServerAdapter extends EventEmitter implements IWebServerAdapter {
   public constructor(protected readonly webServer: Server) {
-    debug('created')
+    logger('created')
     super()
     this.webServer
       .on('error', this.onError.bind(this))
@@ -18,39 +18,39 @@ export class WebServerAdapter extends EventEmitter implements IWebServerAdapter
   }
 
   public listen(port: number): void {
-    debug('attempt to listen on port %d', port)
+    logger('attempt to listen on port %d', port)
     this.webServer.listen(port)
   }
 
   private onListening() {
-    debug('listening for incoming connections')
+    logger('listening for incoming connections')
   }
 
   private onError(error: Error) {
-    debug.error('web-server-adapter: error:', error)
+    logger.error('web-server-adapter: error:', error)
   }
 
   private onClientError(error: Error, socket: Duplex) {
     if (error['code'] === 'ECONNRESET' || !socket.writable) {
       return
     }
-    debug.error('web-server-adapter: client socket error:', error)
+    logger.error('web-server-adapter: client socket error:', error)
     socket.end('HTTP/1.1 400 Bad Request\r\nContent-Type: text/html\r\n')
   }
 
   public close(callback?: () => void): void {
-    debug('closing')
+    logger('closing')
     this.webServer.close(() => {
       this.webServer.removeAllListeners()
       this.removeAllListeners()
       if (typeof callback !== 'undefined') {
         callback()
       }
     })
-    debug('closed')
+    logger('closed')
   }
 
   protected onClose() {
-    debug('stopped listening to incoming connections')
+    logger('stopped listening to incoming connections')
   }
 }

src/adapters/web-socket-adapter.ts

@@ -22,8 +22,8 @@ import { messageSchema } from '../schemas/message-schema'
 import { Settings } from '../@types/settings'
 import { SocketAddress } from 'net'
 
-const debug = createLogger('web-socket-adapter')
-const debugHeartbeat = debug.extend('heartbeat')
+const logger = createLogger('web-socket-adapter')
+const debugHeartbeat = logger.extend('heartbeat')
 
 const abortableMessageHandlers: WeakMap<WebSocket, IAbortable[]> = new WeakMap()
 
@@ -57,11 +57,11 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
     this.client
       .on('error', (error) => {
         if (error.name === 'RangeError' && error.message === 'Max payload size exceeded') {
-          debug.error(`web-socket-adapter: client ${this.clientId} (${this.getClientAddress()}) sent payload too large`)
+          logger.error(`web-socket-adapter: client ${this.clientId} (${this.getClientAddress()}) sent payload too large`)
         } else if (error.name === 'RangeError' && error.message === 'Invalid WebSocket frame: RSV1 must be clear') {
-          debug(`client ${this.clientId} (${this.getClientAddress()}) enabled compression`)
+          logger(`client ${this.clientId} (${this.getClientAddress()}) enabled compression`)
         } else {
-          debug.error(`web-socket-adapter: client error ${this.clientId} (${this.getClientAddress()}):`, error)
+          logger.error(`web-socket-adapter: client error ${this.clientId} (${this.getClientAddress()}):`, error)
         }
 
         this.client.close()
@@ -78,7 +78,7 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
       .on(WebSocketAdapterEvent.Broadcast, this.onBroadcast.bind(this))
       .on(WebSocketAdapterEvent.Message, this.sendMessage.bind(this))
 
-    debug('client %s connected from %s', this.clientId, this.clientAddress.address)
+    logger('client %s connected from %s', this.clientId, this.clientAddress.address)
   }
 
   public getClientId(): string {
@@ -90,12 +90,12 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
   }
 
   public onUnsubscribed(subscriptionId: string): void {
-    debug('client %s unsubscribed %s', this.clientId, subscriptionId)
+    logger('client %s unsubscribed %s', this.clientId, subscriptionId)
     this.subscriptions.delete(subscriptionId)
   }
 
   public onSubscribed(subscriptionId: string, filters: SubscriptionFilter[]): void {
-    debug('client %s subscribed %s to %o', this.clientId, subscriptionId, filters)
+    logger('client %s subscribed %s to %o', this.clientId, subscriptionId, filters)
     this.subscriptions.set(subscriptionId, filters)
   }
 
@@ -112,7 +112,7 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
   public onSendEvent(event: Event): void {
     this.subscriptions.forEach((filters, subscriptionId) => {
       if (filters.map(isEventMatchingFilter).some((isMatch) => isMatch(event))) {
-        debug('sending event to client %s: %o', this.clientId, event)
+        logger('sending event to client %s: %o', this.clientId, event)
         this.sendMessage(createOutgoingEventMessage(subscriptionId, event))
       }
     })
@@ -127,7 +127,7 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
 
   public onHeartbeat(): void {
     if (!this.alive && !this.subscriptions.size) {
-      debug.error(`web-socket-adapter: pong timeout for client ${this.clientId} (${this.getClientAddress()})`)
+      logger.error(`web-socket-adapter: pong timeout for client ${this.clientId} (${this.getClientAddress()})`)
       this.client.close()
       return
     }
@@ -159,7 +159,7 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
 
       messageHandler = this.createMessageHandler([message, this]) as IMessageHandler & IAbortable
       if (!messageHandler) {
-        debug.error('web-socket-adapter: unhandled message: no handler found:', message)
+        logger.error('web-socket-adapter: unhandled message: no handler found:', message)
         return
       }
 
@@ -175,19 +175,19 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
     } catch (error) {
       if (error instanceof Error) {
         if (error.name === 'AbortError') {
-          debug.error(`web-socket-adapter: abort from client ${this.clientId} (${this.getClientAddress()})`)
+          logger.error(`web-socket-adapter: abort from client ${this.clientId} (${this.getClientAddress()})`)
         } else if (error.name === 'SyntaxError' || error instanceof ZodError) {
-          debug('invalid message client %s (%s): %s', this.clientId, this.getClientAddress(), error.message)
+          logger('invalid message client %s (%s): %s', this.clientId, this.getClientAddress(), error.message)
           const notice =
             error instanceof ZodError
               ? `invalid: ${error.issues[0]?.message ?? error.message}`
               : `invalid: ${error.message}`
           this.sendMessage(createNoticeMessage(notice))
         } else {
-          debug.error('web-socket-adapter: unable to handle message:', error)
+          logger.error('web-socket-adapter: unable to handle message:', error)
         }
       } else {
-        debug.error('web-socket-adapter: unable to handle message:', error)
+        logger.error('web-socket-adapter: unable to handle message:', error)
       }
     } finally {
       if (abortable && messageHandler) {
@@ -218,7 +218,7 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
       const isRateLimited = await hit(period, rate)
 
       if (isRateLimited) {
-        debug('rate limited %s: %d messages / %d ms exceeded', client, rate, period)
+        logger('rate limited %s: %d messages / %d ms exceeded', client, rate, period)
 
         limited = true
       }
@@ -248,7 +248,7 @@ export class WebSocketAdapter extends EventEmitter implements IWebSocketAdapter
         try {
           handler.abort()
         } catch (error) {
-          debug.error('Unable to abort message handler', error)
+          logger.error('Unable to abort message handler', error)
         }
       }
     }

src/adapters/web-socket-server-adapter.ts

@@ -12,7 +12,7 @@ import { isRateLimited } from '../handlers/request-handlers/rate-limiter-middlew
 import { Settings } from '../@types/settings'
 import { WebServerAdapter } from './web-server-adapter'
 
-const debug = createLogger('web-socket-server-adapter')
+const logger = createLogger('web-socket-server-adapter')
 
 const WSS_CLIENT_HEALTH_PROBE_INTERVAL = 120000
 
@@ -30,7 +30,7 @@ export class WebSocketServerAdapter extends WebServerAdapter implements IWebSock
     >,
     private readonly settings: () => Settings,
   ) {
-    debug('created')
+    logger('created')
     super(webServer)
 
     this.webSocketsAdapters = new WeakMap()
@@ -40,29 +40,29 @@ export class WebSocketServerAdapter extends WebServerAdapter implements IWebSock
     this.webSocketServer
       .on(WebSocketServerAdapterEvent.Connection, this.onConnection.bind(this))
       .on('error', (error) => {
-        debug('error: %o', error)
+        logger('error: %o', error)
       })
     this.heartbeatInterval = setInterval(this.onHeartbeat.bind(this), WSS_CLIENT_HEALTH_PROBE_INTERVAL)
   }
 
   public close(callback?: () => void): void {
     super.close(() => {
-      debug('closing')
+      logger('closing')
       clearInterval(this.heartbeatInterval)
       this.webSocketServer.clients.forEach((webSocket: WebSocket) => {
         const webSocketAdapter = this.webSocketsAdapters.get(webSocket)
         if (webSocketAdapter) {
-          debug('terminating client %s: %s', webSocketAdapter.getClientId(), webSocketAdapter.getClientAddress())
+          logger('terminating client %s: %s', webSocketAdapter.getClientId(), webSocketAdapter.getClientAddress())
         }
         webSocket.terminate()
       })
-      debug('closing web socket server')
+      logger('closing web socket server')
       this.webSocketServer.close(() => {
         this.webSocketServer.removeAllListeners()
         if (typeof callback !== 'undefined') {
           callback()
         }
-        debug('closed')
+        logger('closed')
       })
     })
     this.removeAllListeners()
@@ -89,10 +89,10 @@ export class WebSocketServerAdapter extends WebServerAdapter implements IWebSock
     const currentSettings = this.settings()
     const remoteAddress = getRemoteAddress(req, currentSettings)
 
-    debug('client %s connected: %o', remoteAddress, req.headers)
+    logger('client %s connected: %o', remoteAddress, req.headers)
 
     if (await isRateLimited(remoteAddress, currentSettings)) {
-      debug('client %s terminated: rate-limited', remoteAddress)
+      logger('client %s terminated: rate-limited', remoteAddress)
       client.terminate()
       return
     }