@prsm/realtime 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prsm/realtime",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Distributed WebSocket framework with Redis-backed rooms, records, presence, channels, collections, and persistence",
   "type": "module",
   "license": "ISC",
@@ -20,6 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@prsm/log": "^1.0.1",
     "eventemitter3": "^5.0.1",
     "fast-json-patch": "^3.1.1",
     "ioredis": "^5.6.1",

package/src/adapters/postgres.js

@@ -5,9 +5,9 @@ export function createPostgresAdapter(options = {}) {
   const opts = {
     host: "localhost",
     port: 5432,
-    database: "mesh_test",
-    user: "mesh",
-    password: "mesh_password",
+    database: "realtime_test",
+    user: "realtime",
+    password: "realtime_password",
     max: 10,
     ...options,
   }
@@ -49,7 +49,7 @@ export function createPostgresAdapter(options = {}) {
         await createTables()
         initialized = true
       } catch (err) {
-        serverLogger.error("Error initializing PostgreSQL database:", err)
+        serverLogger.error("error initializing postgresql database", { err })
         throw err
       }
     },

package/src/client/client.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from "eventemitter3"
 import { Connection } from "./connection.js"
-import { clientLogger, CodeError, LogLevel, Status } from "../shared/index.js"
+import { clientLogger, configureLogLevel, CodeError, LogLevel, Status } from "../shared/index.js"
 import { createRecordSubscriptions } from "./subscriptions/records.js"
 import { createChannelSubscriptions } from "./subscriptions/channels.js"
 import { createPresenceSubscriptions } from "./subscriptions/presence.js"
@@ -43,7 +43,7 @@ export class RealtimeClient extends EventEmitter {
       logLevel: opts.logLevel ?? LogLevel.ERROR,
     }
 
-    clientLogger.configure({ level: this.options.logLevel, styling: true })
+    configureLogLevel(this.options.logLevel)
 
     this.recordSubscriptions = new Map()
     this.collectionSubscriptions = new Map()
@@ -169,13 +169,13 @@ export class RealtimeClient extends EventEmitter {
   async getConnectionMetadata(connectionId) {
     try {
       if (connectionId) {
-        const result = await this.command("mesh/get-connection-metadata", { connectionId })
+        const result = await this.command("rt/get-connection-metadata", { connectionId })
         return result.metadata
       }
-      const result = await this.command("mesh/get-my-connection-metadata")
+      const result = await this.command("rt/get-my-connection-metadata")
       return result.metadata
     } catch (error) {
-      clientLogger.error(`Failed to get metadata for connection:`, error)
+      clientLogger.error("failed to get metadata for connection", { err: error })
       return null
     }
   }
@@ -187,10 +187,10 @@ export class RealtimeClient extends EventEmitter {
    */
   async setConnectionMetadata(metadata, options) {
     try {
-      const result = await this.command("mesh/set-my-connection-metadata", { metadata, options })
+      const result = await this.command("rt/set-my-connection-metadata", { metadata, options })
       return result.success
     } catch (error) {
-      clientLogger.error(`Failed to set metadata for connection:`, error)
+      clientLogger.error("failed to set metadata for connection", { err: error })
       return false
     }
   }
@@ -199,11 +199,11 @@ export class RealtimeClient extends EventEmitter {
     this.connection.on("message", (data) => {
       this.emit("message", data)
 
-      if (data.command === "mesh/record-update") this._records.handleUpdate(data.payload)
-      else if (data.command === "mesh/record-deleted") this._records.handleDeleted(data.payload)
-      else if (data.command === "mesh/presence-update") this._presence.handleUpdate(data.payload)
-      else if (data.command === "mesh/subscription-message") this._channels.handleMessage(data.payload)
-      else if (data.command === "mesh/collection-diff") this._collections.handleDiff(data.payload)
+      if (data.command === "rt/record-update") this._records.handleUpdate(data.payload)
+      else if (data.command === "rt/record-deleted") this._records.handleDeleted(data.payload)
+      else if (data.command === "rt/presence-update") this._presence.handleUpdate(data.payload)
+      else if (data.command === "rt/subscription-message") this._channels.handleMessage(data.payload)
+      else if (data.command === "rt/collection-diff") this._collections.handleDiff(data.payload)
       else {
         const systemCommands = ["ping", "pong", "latency", "latency:request", "latency:response"]
         if (data.command && !systemCommands.includes(data.command)) {
@@ -238,9 +238,9 @@ export class RealtimeClient extends EventEmitter {
             this._lastActivityTime = Date.now()
             if (eventName === "visibilitychange" && doc.visibilityState === "visible") {
               if (this._status === Status.OFFLINE) return
-              this.command("mesh/noop", {}, 5000)
-                .then(() => { clientLogger.info("Tab visible, connection ok"); this.emit("republish") })
-                .catch(() => { clientLogger.info("Tab visible, forcing reconnect"); this._forceReconnect() })
+              this.command("rt/noop", {}, 5000)
+                .then(() => { clientLogger.info("tab visible, connection ok"); this.emit("republish") })
+                .catch(() => { clientLogger.info("tab visible, forcing reconnect"); this._forceReconnect() })
             }
           })
         })
@@ -253,8 +253,8 @@ export class RealtimeClient extends EventEmitter {
     const now = Date.now()
     const timeSinceActivity = now - this._lastActivityTime
     if (timeSinceActivity > this.options.pingTimeout && this._status === Status.ONLINE) {
-      this.command("mesh/noop", {}, 5000).catch(() => {
-        clientLogger.info(`No activity for ${timeSinceActivity}ms, forcing reconnect`)
+      this.command("rt/noop", {}, 5000).catch(() => {
+        clientLogger.info("no activity, forcing reconnect", { timeSinceActivity })
         this._forceReconnect()
       })
     }
@@ -325,7 +325,7 @@ export class RealtimeClient extends EventEmitter {
     this.missedPings++
     if (this.missedPings > this.options.maxMissedPings) {
       if (this.options.shouldReconnect) {
-        clientLogger.warn(`Missed ${this.missedPings} pings, reconnecting...`)
+        clientLogger.warn("missed pings, reconnecting", { missedPings: this.missedPings })
         this.reconnect()
       }
     } else {
@@ -418,7 +418,7 @@ export class RealtimeClient extends EventEmitter {
   }
 
   async _resubscribeAll() {
-    clientLogger.info("Resubscribing to all subscriptions after reconnect")
+    clientLogger.info("resubscribing to all subscriptions after reconnect")
     try {
       const successfulRooms = await this._rooms.resubscribe()
       await Promise.allSettled([
@@ -430,12 +430,12 @@ export class RealtimeClient extends EventEmitter {
       if (successfulRooms.length > 0) {
         for (const roomName of successfulRooms) {
           try { await this._presence.forceUpdate(roomName) }
-          catch (err) { clientLogger.error(`Error refreshing presence for room ${roomName}:`, err) }
+          catch (err) { clientLogger.error("error refreshing presence for room", { roomName, err }) }
           await new Promise((resolve) => setTimeout(resolve, 50))
         }
       }
     } catch (error) {
-      clientLogger.error("Error during resubscription:", error)
+      clientLogger.error("error during resubscription", { err: error })
     }
   }
 }

package/src/client/connection.js

@@ -91,7 +91,7 @@ export class Connection extends EventEmitter {
 
         this.emit("message", data);
 
-        if (data.command === "mesh/assign-id") {
+        if (data.command === "rt/assign-id") {
           this.connectionId = data.payload;
           this.emit("id-assigned", data.payload);
         } else if (data.command === "latency:request") {

package/src/client/subscriptions/channels.js

@@ -10,7 +10,7 @@ export function createChannelSubscriptions(client) {
       try {
         await subscription.callback(message)
       } catch (error) {
-        clientLogger.error(`Error in channel callback for ${channel}:`, error)
+        clientLogger.error("error in channel callback", { channel, err: error })
       }
     }
   }
@@ -23,7 +23,7 @@ export function createChannelSubscriptions(client) {
    */
   async function subscribe(channel, callback, options) {
     subscriptions.set(channel, { callback, historyLimit: options?.historyLimit })
-    const result = await client.command("mesh/subscribe-channel", {
+    const result = await client.command("rt/subscribe-channel", {
       channel,
       historyLimit: options?.historyLimit,
       since: options?.since,
@@ -40,7 +40,7 @@ export function createChannelSubscriptions(client) {
    */
   function unsubscribe(channel) {
     subscriptions.delete(channel)
-    return client.command("mesh/unsubscribe-channel", { channel })
+    return client.command("rt/unsubscribe-channel", { channel })
   }
 
   /**
@@ -50,14 +50,14 @@ export function createChannelSubscriptions(client) {
    */
   async function getHistory(channel, options) {
     try {
-      const result = await client.command("mesh/get-channel-history", {
+      const result = await client.command("rt/get-channel-history", {
         channel,
         limit: options?.limit,
         since: options?.since,
       })
       return { success: result.success, history: result.history || [] }
     } catch (error) {
-      clientLogger.error(`Failed to get history for channel ${channel}:`, error)
+      clientLogger.error("failed to get history for channel", { channel, err: error })
       return { success: false, history: [] }
     }
   }
@@ -68,7 +68,7 @@ export function createChannelSubscriptions(client) {
         await subscribe(channel, callback, { historyLimit })
         return true
       } catch (error) {
-        clientLogger.error(`Failed to resubscribe to channel ${channel}:`, error)
+        clientLogger.error("failed to resubscribe to channel", { channel, err: error })
         return false
       }
     })

package/src/client/subscriptions/collections.js

@@ -9,9 +9,7 @@ export function createCollectionSubscriptions(client) {
     if (!subscription) return
 
     if (version !== subscription.version + 1) {
-      clientLogger.warn(
-        `Desync detected for collection ${collectionId}. Expected version ${subscription.version + 1}, got ${version}. Resubscribing.`
-      )
+      clientLogger.warn("desync detected for collection, resubscribing", { collectionId, expected: subscription.version + 1, got: version })
       await unsubscribe(collectionId)
       await subscribe(collectionId, { onDiff: subscription.onDiff })
       return
@@ -30,7 +28,7 @@ export function createCollectionSubscriptions(client) {
           version,
         })
       } catch (error) {
-        clientLogger.error(`Error in collection diff callback for ${collectionId}:`, error)
+        clientLogger.error("error in collection diff callback", { collectionId, err: error })
       }
     }
   }
@@ -42,7 +40,7 @@ export function createCollectionSubscriptions(client) {
    */
   async function subscribe(collectionId, options = {}) {
     try {
-      const result = await client.command("mesh/subscribe-collection", { collectionId })
+      const result = await client.command("rt/subscribe-collection", { collectionId })
       if (result.success) {
         subscriptions.set(collectionId, {
           ids: new Set(result.ids),
@@ -53,13 +51,13 @@ export function createCollectionSubscriptions(client) {
           try {
             await options.onDiff({ added: result.records, removed: [], changed: [], version: result.version })
           } catch (error) {
-            clientLogger.error(`Error in initial collection diff callback for ${collectionId}:`, error)
+            clientLogger.error("error in initial collection diff callback", { collectionId, err: error })
           }
         }
       }
       return { success: result.success, ids: result.ids || [], records: result.records || [], version: result.version || 0 }
     } catch (error) {
-      clientLogger.error(`Failed to subscribe to collection ${collectionId}:`, error)
+      clientLogger.error("failed to subscribe to collection", { collectionId, err: error })
       return { success: false, ids: [], records: [], version: 0 }
     }
   }
@@ -70,11 +68,11 @@ export function createCollectionSubscriptions(client) {
    */
   async function unsubscribe(collectionId) {
     try {
-      const success = await client.command("mesh/unsubscribe-collection", { collectionId })
+      const success = await client.command("rt/unsubscribe-collection", { collectionId })
       if (success) subscriptions.delete(collectionId)
       return success
     } catch (error) {
-      clientLogger.error(`Failed to unsubscribe from collection ${collectionId}:`, error)
+      clientLogger.error("failed to unsubscribe from collection", { collectionId, err: error })
       return false
     }
   }
@@ -85,7 +83,7 @@ export function createCollectionSubscriptions(client) {
         await subscribe(collectionId, { onDiff: subscription.onDiff })
         return true
       } catch (error) {
-        clientLogger.error(`Failed to resubscribe to collection ${collectionId}:`, error)
+        clientLogger.error("failed to resubscribe to collection", { collectionId, err: error })
         return false
       }
     })

package/src/client/subscriptions/presence.js

@@ -16,14 +16,14 @@ export function createPresenceSubscriptions(client) {
    */
   async function subscribe(roomName, callback) {
     try {
-      const result = await client.command("mesh/subscribe-presence", { roomName })
+      const result = await client.command("rt/subscribe-presence", { roomName })
       if (result.success) {
         subscriptions.set(roomName, callback)
         if (result.present && result.present.length > 0) await callback(result)
       }
       return { success: result.success, present: result.present || [], states: result.states || {} }
     } catch (error) {
-      clientLogger.error(`Failed to subscribe to presence for room ${roomName}:`, error)
+      clientLogger.error("failed to subscribe to presence for room", { roomName, err: error })
       return { success: false, present: [] }
     }
   }
@@ -34,11 +34,11 @@ export function createPresenceSubscriptions(client) {
    */
   async function unsubscribe(roomName) {
     try {
-      const success = await client.command("mesh/unsubscribe-presence", { roomName })
+      const success = await client.command("rt/unsubscribe-presence", { roomName })
       if (success) subscriptions.delete(roomName)
       return success
     } catch (error) {
-      clientLogger.error(`Failed to unsubscribe from presence for room ${roomName}:`, error)
+      clientLogger.error("failed to unsubscribe from presence for room", { roomName, err: error })
       return false
     }
   }
@@ -50,14 +50,14 @@ export function createPresenceSubscriptions(client) {
    */
   async function publishState(roomName, options) {
     try {
-      return await client.command("mesh/publish-presence-state", {
+      return await client.command("rt/publish-presence-state", {
         roomName,
         state: options.state,
         expireAfter: options.expireAfter,
         silent: options.silent,
       })
     } catch (error) {
-      clientLogger.error(`Failed to publish presence state for room ${roomName}:`, error)
+      clientLogger.error("failed to publish presence state for room", { roomName, err: error })
       return false
     }
   }
@@ -68,9 +68,9 @@ export function createPresenceSubscriptions(client) {
    */
   async function clearState(roomName) {
     try {
-      return await client.command("mesh/clear-presence-state", { roomName })
+      return await client.command("rt/clear-presence-state", { roomName })
     } catch (error) {
-      clientLogger.error(`Failed to clear presence state for room ${roomName}:`, error)
+      clientLogger.error("failed to clear presence state for room", { roomName, err: error })
       return false
     }
   }
@@ -79,8 +79,8 @@ export function createPresenceSubscriptions(client) {
     try {
       const handler = subscriptions.get(roomName)
       if (!handler) return false
-      const result = await client.command("mesh/get-presence-state", { roomName }, 5000).catch((err) => {
-        clientLogger.error(`Failed to get presence state for room ${roomName}:`, err)
+      const result = await client.command("rt/get-presence-state", { roomName }, 5000).catch((err) => {
+        clientLogger.error("failed to get presence state for room", { roomName, err })
         return { success: false }
       })
       if (!result.success) return false
@@ -89,7 +89,7 @@ export function createPresenceSubscriptions(client) {
       }
       return true
     } catch (error) {
-      clientLogger.error(`Failed to force presence update for room ${roomName}:`, error)
+      clientLogger.error("failed to force presence update for room", { roomName, err: error })
       return false
     }
   }

package/src/client/subscriptions/records.js

@@ -16,7 +16,7 @@ export function createRecordSubscriptions(client) {
             version,
           })
         } catch (error) {
-          clientLogger.error(`Error in collection record update callback for ${collectionId}:`, error)
+          clientLogger.error("error in collection record update callback", { collectionId, err: error })
         }
       }
     }
@@ -26,9 +26,7 @@ export function createRecordSubscriptions(client) {
 
     if (patch) {
       if (version !== subscription.localVersion + 1) {
-        clientLogger.warn(
-          `Desync detected for record ${recordId}. Expected version ${subscription.localVersion + 1}, got ${version}. Resubscribing to request full record.`
-        )
+        clientLogger.warn("desync detected for record, resubscribing", { recordId, expected: subscription.localVersion + 1, got: version })
         await unsubscribe(recordId)
         await subscribe(recordId, subscription.callback, { mode: subscription.mode })
         return
@@ -48,7 +46,7 @@ export function createRecordSubscriptions(client) {
       try {
         await subscription.callback({ recordId, deleted: true, version })
       } catch (error) {
-        clientLogger.error(`Error in record deletion callback for ${recordId}:`, error)
+        clientLogger.error("error in record deletion callback", { recordId, err: error })
       }
     }
     subscriptions.delete(recordId)
@@ -63,14 +61,14 @@ export function createRecordSubscriptions(client) {
   async function subscribe(recordId, callback, options) {
     const mode = options?.mode ?? "full"
     try {
-      const result = await client.command("mesh/subscribe-record", { recordId, mode })
+      const result = await client.command("rt/subscribe-record", { recordId, mode })
       if (result.success) {
         subscriptions.set(recordId, { callback, localVersion: result.version, mode })
         if (callback) await callback({ recordId, full: result.record, version: result.version })
       }
       return { success: result.success, record: result.record ?? null, version: result.version ?? 0 }
     } catch (error) {
-      clientLogger.error(`Failed to subscribe to record ${recordId}:`, error)
+      clientLogger.error("failed to subscribe to record", { recordId, err: error })
       return { success: false, record: null, version: 0 }
     }
   }
@@ -81,11 +79,11 @@ export function createRecordSubscriptions(client) {
    */
   async function unsubscribe(recordId) {
     try {
-      const success = await client.command("mesh/unsubscribe-record", { recordId })
+      const success = await client.command("rt/unsubscribe-record", { recordId })
       if (success) subscriptions.delete(recordId)
       return success
     } catch (error) {
-      clientLogger.error(`Failed to unsubscribe from record ${recordId}:`, error)
+      clientLogger.error("failed to unsubscribe from record", { recordId, err: error })
       return false
     }
   }
@@ -98,10 +96,10 @@ export function createRecordSubscriptions(client) {
    */
   async function write(recordId, newValue, options) {
     try {
-      const result = await client.command("mesh/publish-record-update", { recordId, newValue, options })
+      const result = await client.command("rt/publish-record-update", { recordId, newValue, options })
       return result.success === true
     } catch (error) {
-      clientLogger.error(`Failed to publish update for record ${recordId}:`, error)
+      clientLogger.error("failed to publish update for record", { recordId, err: error })
       return false
     }
   }
@@ -112,7 +110,7 @@ export function createRecordSubscriptions(client) {
         await subscribe(recordId, callback, { mode })
         return true
       } catch (error) {
-        clientLogger.error(`Failed to resubscribe to record ${recordId}:`, error)
+        clientLogger.error("failed to resubscribe to record", { recordId, err: error })
         return false
       }
     })

package/src/client/subscriptions/rooms.js

@@ -9,7 +9,7 @@ export function createRoomSubscriptions(client, presence) {
    * @returns {Promise<{success: boolean, present: string[]}>}
    */
   async function join(roomName, onPresenceUpdate) {
-    const joinResult = await client.command("mesh/join-room", { roomName })
+    const joinResult = await client.command("rt/join-room", { roomName })
     if (!joinResult.success) return { success: false, present: [] }
 
     joinedRooms.set(roomName, onPresenceUpdate)
@@ -25,7 +25,7 @@ export function createRoomSubscriptions(client, presence) {
    * @returns {Promise<{success: boolean}>}
    */
   async function leave(roomName) {
-    const result = await client.command("mesh/leave-room", { roomName })
+    const result = await client.command("rt/leave-room", { roomName })
     if (result.success) {
       joinedRooms.delete(roomName)
       if (client.presenceSubscriptions.has(roomName)) {
@@ -41,10 +41,10 @@ export function createRoomSubscriptions(client, presence) {
    */
   async function getMetadata(roomName) {
     try {
-      const result = await client.command("mesh/get-room-metadata", { roomName })
+      const result = await client.command("rt/get-room-metadata", { roomName })
       return result.metadata
     } catch (error) {
-      clientLogger.error(`Failed to get metadata for room ${roomName}:`, error)
+      clientLogger.error("failed to get metadata for room", { roomName, err: error })
       return null
     }
   }
@@ -55,7 +55,7 @@ export function createRoomSubscriptions(client, presence) {
         await join(roomName, presenceCallback)
         return { roomName, success: true }
       } catch (error) {
-        clientLogger.error(`Failed to rejoin room ${roomName}:`, error)
+        clientLogger.error("failed to rejoin room", { roomName, err: error })
         return { roomName, success: false }
       }
     })

package/src/server/connection.js

@@ -39,7 +39,7 @@ export class Connection extends EventEmitter {
         this.missedPongs++
         const maxMissedPongs = this.connectionOptions.maxMissedPongs ?? 1
         if (this.missedPongs > maxMissedPongs) {
-          serverLogger.info(`Closing connection (${this.id}) due to missed pongs`)
+          serverLogger.info("closing connection due to missed pongs", { connectionId: this.id })
           this.close()
           this.server.cleanupConnection(this)
           return
@@ -59,7 +59,7 @@ export class Connection extends EventEmitter {
 
   _applyListeners() {
     this.socket.on("close", () => {
-      serverLogger.info("Client's socket closed:", this.id)
+      serverLogger.info("client socket closed", { connectionId: this.id })
       this.status = Status.OFFLINE
       this.emit("close")
     })

package/src/server/managers/channels.js

@@ -36,8 +36,8 @@ export class ChannelManager {
     const serialized = typeof message === "string" ? message : JSON.stringify(message)
     const parsedHistory = parseInt(history, 10)
     if (!isNaN(parsedHistory) && parsedHistory > 0) {
-      await this.pubClient.rpush(`mesh:history:${channel}`, serialized)
-      await this.pubClient.ltrim(`mesh:history:${channel}`, -parsedHistory, -1)
+      await this.pubClient.rpush(`rt:history:${channel}`, serialized)
+      await this.pubClient.ltrim(`rt:history:${channel}`, -parsedHistory, -1)
     }
     this.messageStream.publishMessage(channel, serialized, instanceId)
     await this.pubClient.publish(channel, serialized)
@@ -89,11 +89,11 @@ export class ChannelManager {
         const messages = await this.persistenceManager.getMessages(channel, since, limit)
         return messages.map((msg) => msg.message)
       } catch {
-        const historyKey = `mesh:history:${channel}`
+        const historyKey = `rt:history:${channel}`
         return this.redis.lrange(historyKey, 0, limit - 1)
       }
     }
-    const historyKey = `mesh:history:${channel}`
+    const historyKey = `rt:history:${channel}`
     return this.redis.lrange(historyKey, 0, limit - 1)
   }
 

package/src/server/managers/collections.js

@@ -38,7 +38,7 @@ export class CollectionManager {
     const ids = records.map((record) => record.id)
     const version = 1
     this.collectionSubscriptions.get(collectionId).set(connectionId, { version })
-    await this.redis.set(`mesh:collection:${collectionId}:${connectionId}`, JSON.stringify(ids))
+    await this.redis.set(`rt:collection:${collectionId}:${connectionId}`, JSON.stringify(ids))
     return { ids, records, version }
   }
 
@@ -47,7 +47,7 @@ export class CollectionManager {
     if (collectionSubs?.has(connectionId)) {
       collectionSubs.delete(connectionId)
       if (collectionSubs.size === 0) this.collectionSubscriptions.delete(collectionId)
-      await this.redis.del(`mesh:collection:${collectionId}:${connectionId}`)
+      await this.redis.del(`rt:collection:${collectionId}:${connectionId}`)
       return true
     }
     return false
@@ -55,7 +55,7 @@ export class CollectionManager {
 
   async publishRecordChange(recordId) {
     try {
-      await this.redis.publish("mesh:collection:record-change", recordId)
+      await this.redis.publish("rt:collection:record-change", recordId)
     } catch (error) {
       this.emitError(new Error(`Failed to publish record change for ${recordId}: ${error}`))
     }
@@ -69,7 +69,7 @@ export class CollectionManager {
       subscribers.delete(connectionId)
       if (subscribers.size === 0) this.collectionSubscriptions.delete(collectionId)
       cleanupPromises.push(
-        this.redis.del(`mesh:collection:${collectionId}:${connectionId}`).then(() => {}).catch((err) => {
+        this.redis.del(`rt:collection:${collectionId}:${connectionId}`).then(() => {}).catch((err) => {
           this.emitError(new Error(`Failed to clean up collection subscription for "${collectionId}": ${err}`))
         })
       )
@@ -79,7 +79,7 @@ export class CollectionManager {
 
   async listRecordsMatching(pattern, options) {
     try {
-      const recordKeyPrefix = "mesh:record:"
+      const recordKeyPrefix = "rt:record:"
       const keys = []
       let cursor = "0"
       do {

package/src/server/managers/connections.js

@@ -1,8 +1,8 @@
 import { deepMerge, isObject } from "../../shared/index.js"
 
-const CONNECTIONS_HASH_KEY = "mesh:connections"
-const CONNECTIONS_META_HASH_KEY = "mesh:connection-meta"
-const INSTANCE_CONNECTIONS_KEY_PREFIX = "mesh:connections:"
+const CONNECTIONS_HASH_KEY = "rt:connections"
+const CONNECTIONS_META_HASH_KEY = "rt:connection-meta"
+const INSTANCE_CONNECTIONS_KEY_PREFIX = "rt:connections:"
 
 export class ConnectionManager {
   constructor({ redis, instanceId, roomManager }) {