@prsm/realtime 1.0.1 → 1.0.3

package/src/server/server.js

@@ -1,7 +1,7 @@
 import { createServer as createHttpServer } from "node:http"
 import { randomUUID } from "node:crypto"
 import { WebSocketServer } from "ws"
-import { LogLevel, Status, serverLogger, parseCommand } from "../shared/index.js"
+import { LogLevel, configureLogLevel, Status, serverLogger, parseCommand } from "../shared/index.js"
 import { Connection } from "./connection.js"
 import { PUB_SUB_CHANNEL_PREFIX } from "./utils/constants.js"
 import { ConnectionManager } from "./managers/connections.js"
@@ -54,7 +54,7 @@ export class RealtimeServer {
       enablePresenceExpirationEvents: opts.enablePresenceExpirationEvents ?? true,
     }
 
-    serverLogger.configure({ level: this.serverOptions.logLevel, styling: false })
+    configureLogLevel(this.serverOptions.logLevel)
 
     this.redisManager = new RedisManager()
     this.redisManager.initialize(opts.redis, (err) => this._emitError(err))
@@ -159,7 +159,7 @@ export class RealtimeServer {
 
   enableGracefulShutdown() {
     const handler = () => {
-      serverLogger.info("Received shutdown signal, closing...")
+      serverLogger.info("received shutdown signal, closing")
       this.close().then(() => process.exit(0))
     }
     process.on("SIGTERM", handler)
@@ -177,7 +177,7 @@ export class RealtimeServer {
   }
 
   _emitError(err) {
-    serverLogger.error(`Error: ${err}`)
+    serverLogger.error("error", { err })
     for (const handler of this._errorHandlers) handler(err)
   }
 
@@ -292,7 +292,7 @@ export class RealtimeServer {
           pendingAuthDataStore.delete(req)
           await this.connectionManager.setMetadata(connection, authData)
         }
-        connection.send({ command: "mesh/assign-id", payload: connection.id })
+        connection.send({ command: "rt/assign-id", payload: connection.id })
       } catch (error) {
         connection.close()
         return
@@ -490,7 +490,7 @@ export class RealtimeServer {
           if (connection) {
             metadata = await this.connectionManager.getMetadata(connection)
           } else {
-            const metadataString = await this.redisManager.redis.hget("mesh:connection-meta", connectionId)
+            const metadataString = await this.redisManager.redis.hget("rt:connection-meta", connectionId)
             metadata = metadataString ? JSON.parse(metadataString) : null
           }
           return { id: connectionId, metadata }
@@ -582,9 +582,9 @@ export class RealtimeServer {
   }
 
   _registerBuiltinCommands() {
-    this.exposeCommand("mesh/noop", async () => true)
+    this.exposeCommand("rt/noop", async () => true)
 
-    this.exposeCommand("mesh/subscribe-channel", async (ctx) => {
+    this.exposeCommand("rt/subscribe-channel", async (ctx) => {
       const { channel, historyLimit, since } = ctx.payload
       if (!(await this.channelManager.isChannelExposed(channel, ctx.connection))) {
         return { success: false, history: [] }
@@ -601,7 +601,7 @@ export class RealtimeServer {
       }
     })
 
-    this.exposeCommand("mesh/unsubscribe-channel", async (ctx) => {
+    this.exposeCommand("rt/unsubscribe-channel", async (ctx) => {
       const { channel } = ctx.payload
       const wasSubscribed = this.channelManager.removeSubscription(channel, ctx.connection)
       if (wasSubscribed && !this.channelManager.getSubscribers(channel)) {
@@ -610,7 +610,7 @@ export class RealtimeServer {
       return wasSubscribed
     })
 
-    this.exposeCommand("mesh/get-channel-history", async (ctx) => {
+    this.exposeCommand("rt/get-channel-history", async (ctx) => {
       const { channel, limit, since } = ctx.payload
       if (!(await this.channelManager.isChannelExposed(channel, ctx.connection))) {
         return { success: false, history: [] }
@@ -630,44 +630,44 @@ export class RealtimeServer {
       }
     })
 
-    this.exposeCommand("mesh/join-room", async (ctx) => {
+    this.exposeCommand("rt/join-room", async (ctx) => {
       const { roomName } = ctx.payload
       await this.addToRoom(roomName, ctx.connection)
       const present = await this.getRoomMembersWithMetadata(roomName)
       return { success: true, present }
     })
 
-    this.exposeCommand("mesh/leave-room", async (ctx) => {
+    this.exposeCommand("rt/leave-room", async (ctx) => {
       const { roomName } = ctx.payload
       await this.removeFromRoom(roomName, ctx.connection)
       return { success: true }
     })
 
-    this.exposeCommand("mesh/get-connection-metadata", async (ctx) => {
+    this.exposeCommand("rt/get-connection-metadata", async (ctx) => {
       const { connectionId } = ctx.payload
       const connection = this.connectionManager.getLocalConnection(connectionId)
       if (connection) {
         const metadata = await this.connectionManager.getMetadata(connection)
         return { metadata }
       } else {
-        const metadata = await this.redisManager.redis.hget("mesh:connection-meta", connectionId)
+        const metadata = await this.redisManager.redis.hget("rt:connection-meta", connectionId)
         return { metadata: metadata ? JSON.parse(metadata) : null }
       }
     })
 
-    this.exposeCommand("mesh/get-my-connection-metadata", async (ctx) => {
+    this.exposeCommand("rt/get-my-connection-metadata", async (ctx) => {
       const connectionId = ctx.connection.id
       const connection = this.connectionManager.getLocalConnection(connectionId)
       if (connection) {
         const metadata = await this.connectionManager.getMetadata(connection)
         return { metadata }
       } else {
-        const metadata = await this.redisManager.redis.hget("mesh:connection-meta", connectionId)
+        const metadata = await this.redisManager.redis.hget("rt:connection-meta", connectionId)
         return { metadata: metadata ? JSON.parse(metadata) : null }
       }
     })
 
-    this.exposeCommand("mesh/set-my-connection-metadata", async (ctx) => {
+    this.exposeCommand("rt/set-my-connection-metadata", async (ctx) => {
       const { metadata, options } = ctx.payload
       const connectionId = ctx.connection.id
       const connection = this.connectionManager.getLocalConnection(connectionId)
@@ -683,7 +683,7 @@ export class RealtimeServer {
       }
     })
 
-    this.exposeCommand("mesh/get-room-metadata", async (ctx) => {
+    this.exposeCommand("rt/get-room-metadata", async (ctx) => {
       const { roomName } = ctx.payload
       const metadata = await this.roomManager.getMetadata(roomName)
       return { metadata }
@@ -691,7 +691,7 @@ export class RealtimeServer {
   }
 
   _registerRecordCommands() {
-    this.exposeCommand("mesh/subscribe-record", async (ctx) => {
+    this.exposeCommand("rt/subscribe-record", async (ctx) => {
       const { recordId, mode = "full" } = ctx.payload
       const connectionId = ctx.connection.id
       if (!(await this.recordSubscriptionManager.isRecordExposed(recordId, ctx.connection))) {
@@ -702,17 +702,17 @@ export class RealtimeServer {
         this.recordSubscriptionManager.addSubscription(recordId, connectionId, mode)
         return { success: true, record, version }
       } catch (e) {
-        serverLogger.error(`Failed to subscribe to record ${recordId}:`, e)
+        serverLogger.error("failed to subscribe to record", { recordId, err: e })
         return { success: false }
       }
     })
 
-    this.exposeCommand("mesh/unsubscribe-record", async (ctx) => {
+    this.exposeCommand("rt/unsubscribe-record", async (ctx) => {
       const { recordId } = ctx.payload
       return this.recordSubscriptionManager.removeSubscription(recordId, ctx.connection.id)
     })
 
-    this.exposeCommand("mesh/publish-record-update", async (ctx) => {
+    this.exposeCommand("rt/publish-record-update", async (ctx) => {
       const { recordId, newValue, options } = ctx.payload
       if (!(await this.recordSubscriptionManager.isRecordWritable(recordId, ctx.connection))) {
         throw new Error(`Record "${recordId}" is not writable by this connection.`)
@@ -725,13 +725,13 @@ export class RealtimeServer {
       }
     })
 
-    this.exposeCommand("mesh/subscribe-presence", async (ctx) => {
+    this.exposeCommand("rt/subscribe-presence", async (ctx) => {
       const { roomName } = ctx.payload
       if (!(await this.presenceManager.isRoomTracked(roomName, ctx.connection))) {
         return { success: false, present: [] }
       }
       try {
-        const presenceChannel = `mesh:presence:updates:${roomName}`
+        const presenceChannel = `rt:presence:updates:${roomName}`
         this.channelManager.addSubscription(presenceChannel, ctx.connection)
         if (!this.channelManager.getSubscribers(presenceChannel) || this.channelManager.getSubscribers(presenceChannel)?.size === 1) {
           await this.channelManager.subscribeToRedisChannel(presenceChannel)
@@ -742,18 +742,18 @@ export class RealtimeServer {
         statesMap.forEach((state, connectionId) => { states[connectionId] = state })
         return { success: true, present, states }
       } catch (e) {
-        serverLogger.error(`Failed to subscribe to presence for room ${roomName}:`, e)
+        serverLogger.error("failed to subscribe to presence for room", { roomName, err: e })
         return { success: false, present: [] }
       }
     })
 
-    this.exposeCommand("mesh/unsubscribe-presence", async (ctx) => {
+    this.exposeCommand("rt/unsubscribe-presence", async (ctx) => {
       const { roomName } = ctx.payload
-      const presenceChannel = `mesh:presence:updates:${roomName}`
+      const presenceChannel = `rt:presence:updates:${roomName}`
       return this.channelManager.removeSubscription(presenceChannel, ctx.connection)
     })
 
-    this.exposeCommand("mesh/publish-presence-state", async (ctx) => {
+    this.exposeCommand("rt/publish-presence-state", async (ctx) => {
       const { roomName, state, expireAfter, silent } = ctx.payload
       const connectionId = ctx.connection.id
       if (!state) return false
@@ -764,12 +764,12 @@ export class RealtimeServer {
         await this.presenceManager.publishPresenceState(connectionId, roomName, state, expireAfter, silent)
         return true
       } catch (e) {
-        serverLogger.error(`Failed to publish presence state for room ${roomName}:`, e)
+        serverLogger.error("failed to publish presence state for room", { roomName, err: e })
         return false
       }
     })
 
-    this.exposeCommand("mesh/clear-presence-state", async (ctx) => {
+    this.exposeCommand("rt/clear-presence-state", async (ctx) => {
       const { roomName } = ctx.payload
       const connectionId = ctx.connection.id
       if (!(await this.presenceManager.isRoomTracked(roomName, ctx.connection)) || !(await this.isInRoom(roomName, connectionId))) {
@@ -779,12 +779,12 @@ export class RealtimeServer {
         await this.presenceManager.clearPresenceState(connectionId, roomName)
         return true
       } catch (e) {
-        serverLogger.error(`Failed to clear presence state for room ${roomName}:`, e)
+        serverLogger.error("failed to clear presence state for room", { roomName, err: e })
         return false
       }
     })
 
-    this.exposeCommand("mesh/get-presence-state", async (ctx) => {
+    this.exposeCommand("rt/get-presence-state", async (ctx) => {
       const { roomName } = ctx.payload
       if (!(await this.presenceManager.isRoomTracked(roomName, ctx.connection))) {
         return { success: false, present: [] }
@@ -796,12 +796,12 @@ export class RealtimeServer {
         statesMap.forEach((state, connectionId) => { states[connectionId] = state })
         return { success: true, present, states }
       } catch (e) {
-        serverLogger.error(`Failed to get presence state for room ${roomName}:`, e)
+        serverLogger.error("failed to get presence state for room", { roomName, err: e })
         return { success: false, present: [] }
       }
     })
 
-    this.exposeCommand("mesh/subscribe-collection", async (ctx) => {
+    this.exposeCommand("rt/subscribe-collection", async (ctx) => {
       const { collectionId } = ctx.payload
       const connectionId = ctx.connection.id
       if (!(await this.collectionManager.isCollectionExposed(collectionId, ctx.connection))) {
@@ -812,19 +812,19 @@ export class RealtimeServer {
         const recordsWithId = records.map((record) => ({ id: record.id, record }))
         return { success: true, ids, records: recordsWithId, version }
       } catch (e) {
-        serverLogger.error(`Failed to subscribe to collection ${collectionId}:`, e)
+        serverLogger.error("failed to subscribe to collection", { collectionId, err: e })
         return { success: false, ids: [], records: [], version: 0 }
       }
     })
 
-    this.exposeCommand("mesh/unsubscribe-collection", async (ctx) => {
+    this.exposeCommand("rt/unsubscribe-collection", async (ctx) => {
       const { collectionId } = ctx.payload
       return this.collectionManager.removeSubscription(collectionId, ctx.connection.id)
     })
   }
 
   async cleanupConnection(connection) {
-    serverLogger.info("Cleaning up connection:", connection.id)
+    serverLogger.info("cleaning up connection", { connectionId: connection.id })
     connection.stopIntervals()
     try {
       await this.presenceManager.cleanupConnection(connection)
@@ -858,7 +858,7 @@ export class RealtimeServer {
 
     if (this.persistenceManager) {
       try { await this.persistenceManager.shutdown() }
-      catch (err) { serverLogger.error("Error shutting down persistence manager:", err) }
+      catch (err) { serverLogger.error("error shutting down persistence manager", { err }) }
     }
 
     await this.channelManager.cleanupAllSubscriptions()

package/src/server/utils/constants.js

@@ -1,4 +1,4 @@
-export const PUB_SUB_CHANNEL_PREFIX = "mesh:pubsub:"
-export const RECORD_PUB_SUB_CHANNEL = "mesh:record-updates"
-export const RECORD_KEY_PREFIX = "mesh:record:"
-export const RECORD_VERSION_KEY_PREFIX = "mesh:record-version:"
+export const PUB_SUB_CHANNEL_PREFIX = "rt:pubsub:"
+export const RECORD_PUB_SUB_CHANNEL = "rt:record-updates"
+export const RECORD_KEY_PREFIX = "rt:record:"
+export const RECORD_VERSION_KEY_PREFIX = "rt:record-version:"

package/src/shared/index.js

@@ -1,5 +1,5 @@
 export { CodeError } from "./errors.js"
-export { LogLevel, Logger, clientLogger, serverLogger, logger } from "./logger.js"
+export { LogLevel, configureLogLevel, clientLogger, serverLogger, logger } from "./logger.js"
 export { deepMerge, isObject } from "./merge.js"
 export { parseCommand, stringifyCommand } from "./message.js"
 export { Status } from "./status.js"

package/src/shared/logger.js

@@ -1,4 +1,5 @@
-/** @enum {number} */
+import log from "@prsm/log"
+
 export const LogLevel = {
   NONE: 0,
   ERROR: 1,
@@ -7,47 +8,13 @@ export const LogLevel = {
   DEBUG: 4,
 }
 
-const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined"
-
-export class Logger {
-  constructor(config) {
-    this.config = {
-      level: config?.level ?? LogLevel.INFO,
-      prefix: config?.prefix ?? "[mesh]",
-      styling: config?.styling ?? isBrowser,
-    }
-  }
-
-  configure(config) {
-    this.config = { ...this.config, ...config }
-  }
-
-  info(...args) {
-    if (this.config.level >= LogLevel.INFO) this._log("log", ...args)
-  }
-
-  warn(...args) {
-    if (this.config.level >= LogLevel.WARN) this._log("warn", ...args)
-  }
-
-  error(...args) {
-    if (this.config.level >= LogLevel.ERROR) this._log("error", ...args)
-  }
-
-  debug(...args) {
-    if (this.config.level >= LogLevel.DEBUG) this._log("debug", ...args)
-  }
+const levelMap = { 0: "none", 1: "error", 2: "warn", 3: "info", 4: "debug" }
 
-  _log(method, ...args) {
-    if (this.config.styling && isBrowser) {
-      const style = "background: #000; color: #FFA07A; padding: 2px 4px; border-radius: 2px;"
-      console[method](`%c${this.config.prefix}%c`, style, "", ...args)
-    } else {
-      console[method](this.config.prefix, ...args)
-    }
-  }
+export function configureLogLevel(level) {
+  const str = typeof level === "number" ? levelMap[level] ?? "info" : level
+  log.configure({ level: str })
 }
 
-export const clientLogger = new Logger({ level: LogLevel.ERROR, styling: true })
-export const serverLogger = new Logger({ level: LogLevel.ERROR, styling: false })
-export const logger = isBrowser ? clientLogger : serverLogger
+export const serverLogger = log.child({ sys: "server" })
+export const clientLogger = log.child({ sys: "client" })
+export const logger = log