@prsm/realtime 1.0.1 → 1.0.3

package/src/server/managers/instance.js

@@ -28,45 +28,45 @@ export class InstanceManager {
   }
 
   async _registerInstance() {
-    await this.redis.sadd("mesh:instances", this.instanceId)
+    await this.redis.sadd("rt:instances", this.instanceId)
   }
 
   async _deregisterInstance() {
-    await this.redis.srem("mesh:instances", this.instanceId)
-    await this.redis.del(`mesh:instance:${this.instanceId}:heartbeat`)
+    await this.redis.srem("rt:instances", this.instanceId)
+    await this.redis.del(`rt:instance:${this.instanceId}:heartbeat`)
   }
 
   async _updateHeartbeat() {
-    await this.redis.set(`mesh:instance:${this.instanceId}:heartbeat`, Date.now().toString(), "EX", this.heartbeatTTL)
+    await this.redis.set(`rt:instance:${this.instanceId}:heartbeat`, Date.now().toString(), "EX", this.heartbeatTTL)
   }
 
   async _acquireCleanupLock() {
-    const result = await this.redis.set("mesh:cleanup:lock", this.instanceId, "EX", this.cleanupLockTTL, "NX")
+    const result = await this.redis.set("rt:cleanup:lock", this.instanceId, "EX", this.cleanupLockTTL, "NX")
     return result === "OK"
   }
 
   async _releaseCleanupLock() {
     const script = 'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end'
-    await this.redis.eval(script, 1, "mesh:cleanup:lock", this.instanceId)
+    await this.redis.eval(script, 1, "rt:cleanup:lock", this.instanceId)
   }
 
   async _performCleanup() {
     try {
       const lockAcquired = await this._acquireCleanupLock()
       if (!lockAcquired) return
-      const registeredInstances = await this.redis.smembers("mesh:instances")
-      const allConnections = await this.redis.hgetall("mesh:connections")
+      const registeredInstances = await this.redis.smembers("rt:instances")
+      const allConnections = await this.redis.hgetall("rt:connections")
       const instanceIds = new Set([...registeredInstances, ...Object.values(allConnections)])
       for (const instanceId of instanceIds) {
         if (instanceId === this.instanceId) continue
-        const heartbeat = await this.redis.get(`mesh:instance:${instanceId}:heartbeat`)
+        const heartbeat = await this.redis.get(`rt:instance:${instanceId}:heartbeat`)
         if (!heartbeat) {
-          serverLogger.info(`Found dead instance: ${instanceId}`)
+          serverLogger.info("found dead instance", { instanceId })
           await this._cleanupDeadInstance(instanceId)
         }
       }
     } catch (error) {
-      serverLogger.error("Error during cleanup:", error)
+      serverLogger.error("error during cleanup", { err: error })
     } finally {
       await this._releaseCleanupLock()
     }
@@ -74,20 +74,20 @@ export class InstanceManager {
 
   async _cleanupDeadInstance(instanceId) {
     try {
-      const connectionsKey = `mesh:connections:${instanceId}`
+      const connectionsKey = `rt:connections:${instanceId}`
       const connections = await this.redis.smembers(connectionsKey)
       for (const connectionId of connections) {
         await this._cleanupConnection(connectionId)
       }
-      const allConnections = await this.redis.hgetall("mesh:connections")
+      const allConnections = await this.redis.hgetall("rt:connections")
       for (const [connectionId, connInstanceId] of Object.entries(allConnections)) {
         if (connInstanceId === instanceId) await this._cleanupConnection(connectionId)
       }
-      await this.redis.srem("mesh:instances", instanceId)
+      await this.redis.srem("rt:instances", instanceId)
       await this.redis.del(connectionsKey)
-      serverLogger.info(`Cleaned up dead instance: ${instanceId}`)
+      serverLogger.info("cleaned up dead instance", { instanceId })
     } catch (error) {
-      serverLogger.error(`Error cleaning up instance ${instanceId}:`, error)
+      serverLogger.error("error cleaning up instance", { instanceId, err: error })
     }
   }
 
@@ -103,23 +103,23 @@ export class InstanceManager {
 
   async _cleanupConnection(connectionId) {
     try {
-      const roomsKey = `mesh:connection:${connectionId}:rooms`
+      const roomsKey = `rt:connection:${connectionId}:rooms`
       const rooms = await this.redis.smembers(roomsKey)
       const pipeline = this.redis.pipeline()
       for (const room of rooms) {
-        pipeline.srem(`mesh:room:${room}`, connectionId)
-        pipeline.srem(`mesh:presence:room:${room}`, connectionId)
-        pipeline.del(`mesh:presence:room:${room}:conn:${connectionId}`)
-        pipeline.del(`mesh:presence:state:${room}:conn:${connectionId}`)
+        pipeline.srem(`rt:room:${room}`, connectionId)
+        pipeline.srem(`rt:presence:room:${room}`, connectionId)
+        pipeline.del(`rt:presence:room:${room}:conn:${connectionId}`)
+        pipeline.del(`rt:presence:state:${room}:conn:${connectionId}`)
       }
       pipeline.del(roomsKey)
-      pipeline.hdel("mesh:connections", connectionId)
-      pipeline.hdel("mesh:connection-meta", connectionId)
-      await this._deleteMatchingKeys(`mesh:collection:*:${connectionId}`)
+      pipeline.hdel("rt:connections", connectionId)
+      pipeline.hdel("rt:connection-meta", connectionId)
+      await this._deleteMatchingKeys(`rt:collection:*:${connectionId}`)
       await pipeline.exec()
-      serverLogger.debug(`Cleaned up stale connection: ${connectionId}`)
+      serverLogger.debug("cleaned up stale connection", { connectionId })
     } catch (error) {
-      serverLogger.error(`Error cleaning up connection ${connectionId}:`, error)
+      serverLogger.error("error cleaning up connection", { connectionId, err: error })
     }
   }
 }

package/src/server/managers/persistence.js

@@ -34,7 +34,7 @@ export class PersistenceManager extends EventEmitter {
 
   async _processPendingRecordUpdates() {
     if (this.pendingRecordUpdates.length === 0) return
-    serverLogger.info(`Processing ${this.pendingRecordUpdates.length} pending record updates`)
+    serverLogger.info("processing pending record updates", { count: this.pendingRecordUpdates.length })
     const updates = [...this.pendingRecordUpdates]
     this.pendingRecordUpdates = []
     for (const { recordId, value, version } of updates) {
@@ -54,25 +54,25 @@ export class PersistenceManager extends EventEmitter {
       await this._processPendingRecordUpdates()
       this.emit("initialized")
     } catch (err) {
-      serverLogger.error("Failed to initialize persistence manager:", err)
+      serverLogger.error("failed to initialize persistence manager", { err })
       throw err
     }
   }
 
   async restorePersistedRecords() {
     if (!this.recordManager) {
-      serverLogger.warn("Cannot restore persisted records: record manager not available")
+      serverLogger.warn("cannot restore persisted records: record manager not available")
       return
     }
     const redis = this.recordManager.getRedis()
     if (!redis) {
-      serverLogger.warn("Cannot restore records: Redis not available")
+      serverLogger.warn("cannot restore records: redis not available")
       return
     }
     try {
-      serverLogger.info("Restoring persisted records...")
+      serverLogger.info("restoring persisted records")
       if (this.recordPatterns.length === 0) {
-        serverLogger.info("No record patterns to restore")
+        serverLogger.info("no record patterns to restore")
         return
       }
       for (const config of this.recordPatterns) {
@@ -93,7 +93,7 @@ export class PersistenceManager extends EventEmitter {
             }))
           }
           if (records.length > 0) {
-            serverLogger.info(`Restoring ${records.length} records for pattern ${patternLabel}`)
+            serverLogger.info("restoring records for pattern", { count: records.length, pattern: patternLabel })
             for (const record of records) {
               try {
                 const { recordId, value, version } = record
@@ -104,17 +104,17 @@ export class PersistenceManager extends EventEmitter {
                 pipeline.set(versionKey, version.toString())
                 await pipeline.exec()
               } catch (parseErr) {
-                serverLogger.error(`Failed to restore record ${record.recordId}: ${parseErr}`)
+                serverLogger.error("failed to restore record", { recordId: record.recordId, err: parseErr })
               }
             }
           }
         } catch (patternErr) {
-          serverLogger.error(`Error restoring records for pattern ${patternLabel}: ${patternErr}`)
+          serverLogger.error("error restoring records for pattern", { pattern: patternLabel, err: patternErr })
         }
       }
-      serverLogger.info("Finished restoring persisted records")
+      serverLogger.info("finished restoring persisted records")
     } catch (err) {
-      serverLogger.error("Failed to restore persisted records:", err)
+      serverLogger.error("failed to restore persisted records", { err })
     }
   }
 
@@ -133,7 +133,7 @@ export class PersistenceManager extends EventEmitter {
     }
     if (fullOptions.adapter !== this.defaultAdapter && !this.isShuttingDown) {
       fullOptions.adapter.initialize().catch((err) => {
-        serverLogger.error(`Failed to initialize adapter for pattern ${pattern}:`, err)
+        serverLogger.error("failed to initialize adapter for pattern", { pattern, err })
       })
     }
     this.channelPatterns.push({ pattern, options: fullOptions })
@@ -148,7 +148,7 @@ export class PersistenceManager extends EventEmitter {
       resolvedAdapter = { adapter: adapterInstance, restorePattern: adapter.restorePattern }
       if (adapterInstance !== this.defaultAdapter && !this.isShuttingDown) {
         adapterInstance.initialize().catch((err) => {
-          serverLogger.error(`Failed to initialize adapter for record pattern ${pattern}:`, err)
+          serverLogger.error("failed to initialize adapter for record pattern", { pattern, err })
         })
       }
     }
@@ -220,7 +220,7 @@ export class PersistenceManager extends EventEmitter {
       await options.adapter.storeMessages(messages)
       this.emit("flushed", { channel, count: messages.length })
     } catch (err) {
-      serverLogger.error(`Failed to flush messages for channel ${channel}:`, err)
+      serverLogger.error("failed to flush messages for channel", { channel, err })
       if (!this.isShuttingDown) {
         const currentMessages = this.messageBuffer.get(channel) || []
         this.messageBuffer.set(channel, [...messages, ...currentMessages])
@@ -295,7 +295,7 @@ export class PersistenceManager extends EventEmitter {
       }
     }
     const handleFlushError = (failedRecords, err) => {
-      serverLogger.error("Failed to flush records:", err)
+      serverLogger.error("failed to flush records", { err })
       if (!this.isShuttingDown) {
         for (const record of failedRecords) this.recordBuffer.set(record.recordId, record)
         if (!this.recordFlushTimer) {
@@ -337,7 +337,7 @@ export class PersistenceManager extends EventEmitter {
         return await this.defaultAdapter.getRecords(pattern)
       }
     } catch (err) {
-      serverLogger.error(`Failed to get persisted records for pattern ${pattern}:`, err)
+      serverLogger.error("failed to get persisted records for pattern", { pattern, err })
     }
     return []
   }
@@ -364,7 +364,7 @@ export class PersistenceManager extends EventEmitter {
     }
     for (const adapter of adapters) {
       try { await adapter.close() }
-      catch (err) { serverLogger.error("Error closing persistence adapter:", err) }
+      catch (err) { serverLogger.error("error closing persistence adapter", { err }) }
     }
     this.initialized = false
   }

package/src/server/managers/presence.js

@@ -7,8 +7,8 @@ export class PresenceManager {
     this.redisManager = redisManager
     this.presenceExpirationEventsEnabled = enableExpirationEvents
 
-    this.PRESENCE_KEY_PATTERN = /^mesh:presence:room:(.+):conn:(.+)$/
-    this.PRESENCE_STATE_KEY_PATTERN = /^mesh:presence:state:(.+):conn:(.+)$/
+    this.PRESENCE_KEY_PATTERN = /^rt:presence:room:(.+):conn:(.+)$/
+    this.PRESENCE_STATE_KEY_PATTERN = /^rt:presence:state:(.+):conn:(.+)$/
     this.trackedRooms = []
     this.roomGuards = new Map()
     this.roomTTLs = new Map()
@@ -47,7 +47,7 @@ export class PresenceManager {
         await this._publishPresenceStateUpdate(match[1], match[2], null)
       }
     } catch (err) {
-      serverLogger.error("[PresenceManager] Failed to handle expired key:", err)
+      serverLogger.error("failed to handle expired key", { key, err })
     }
   }
 
@@ -89,9 +89,9 @@ export class PresenceManager {
     return this.defaultTTL
   }
 
-  presenceRoomKey(roomName) { return `mesh:presence:room:${roomName}` }
-  presenceConnectionKey(roomName, connectionId) { return `mesh:presence:room:${roomName}:conn:${connectionId}` }
-  presenceStateKey(roomName, connectionId) { return `mesh:presence:state:${roomName}:conn:${connectionId}` }
+  presenceRoomKey(roomName) { return `rt:presence:room:${roomName}` }
+  presenceConnectionKey(roomName, connectionId) { return `rt:presence:room:${roomName}:conn:${connectionId}` }
+  presenceStateKey(roomName, connectionId) { return `rt:presence:state:${roomName}:conn:${connectionId}` }
 
   async markOnline(connectionId, roomName) {
     const roomKey = this.presenceRoomKey(roomName)
@@ -137,7 +137,7 @@ export class PresenceManager {
   }
 
   async _publishPresenceUpdate(roomName, connectionId, type) {
-    const channel = `mesh:presence:updates:${roomName}`
+    const channel = `rt:presence:updates:${roomName}`
     const message = JSON.stringify({ type, connectionId, roomName, timestamp: Date.now() })
     await this.redis.publish(channel, message)
   }
@@ -167,7 +167,7 @@ export class PresenceManager {
     const value = await this.redis.get(key)
     if (!value) return null
     try { return JSON.parse(value) }
-    catch (e) { serverLogger.error(`[PresenceManager] Failed to parse presence state: ${e}`); return null }
+    catch (e) { serverLogger.error("failed to parse presence state", { err: e }); return null }
   }
 
   async getAllPresenceStates(roomName) {
@@ -186,13 +186,13 @@ export class PresenceManager {
       const [err, value] = responses[i] || []
       if (err || !value) continue
       try { result.set(connectionId, JSON.parse(value)) }
-      catch (e) { serverLogger.error(`[PresenceManager] Failed to parse presence state: ${e}`) }
+      catch (e) { serverLogger.error("failed to parse presence state", { err: e }) }
     }
     return result
   }
 
   async _publishPresenceStateUpdate(roomName, connectionId, state) {
-    const channel = `mesh:presence:updates:${roomName}`
+    const channel = `rt:presence:updates:${roomName}`
     const message = JSON.stringify({ type: "state", connectionId, roomName, state, timestamp: Date.now() })
     await this.redis.publish(channel, message)
   }

package/src/server/managers/pubsub.js

@@ -23,8 +23,8 @@ export class PubSubManager {
   subscribeToInstanceChannel() {
     const channel = `${PUB_SUB_CHANNEL_PREFIX}${this.instanceId}`
     this._subscriptionPromise = new Promise((resolve, reject) => {
-      this.subClient.subscribe(channel, RECORD_PUB_SUB_CHANNEL, "mesh:collection:record-change")
-      this.subClient.psubscribe("mesh:presence:updates:*", (err) => {
+      this.subClient.subscribe(channel, RECORD_PUB_SUB_CHANNEL, "rt:collection:record-change")
+      this.subClient.psubscribe("rt:presence:updates:*", (err) => {
         if (err) {
           this.emitError(new Error(`Failed to subscribe to channels/patterns: ${JSON.stringify({ cause: err })}`))
           reject(err)
@@ -43,14 +43,14 @@ export class PubSubManager {
         this._handleInstancePubSubMessage(channel, message)
       } else if (channel === RECORD_PUB_SUB_CHANNEL) {
         this._handleRecordUpdatePubSubMessage(message)
-      } else if (channel === "mesh:collection:record-change") {
+      } else if (channel === "rt:collection:record-change") {
         this._handleCollectionRecordChange(message)
       } else {
         const subscribers = this.getChannelSubscriptions(channel)
         if (subscribers) {
           for (const connection of subscribers) {
             if (!connection.isDead) {
-              connection.send({ command: "mesh/subscription-message", payload: { channel, message } })
+              connection.send({ command: "rt/subscription-message", payload: { channel, message } })
             }
           }
         }
@@ -58,14 +58,14 @@ export class PubSubManager {
     })
 
     this.subClient.on("pmessage", async (pattern, channel, message) => {
-      if (pattern === "mesh:presence:updates:*") {
+      if (pattern === "rt:presence:updates:*") {
         const subscribers = this.getChannelSubscriptions(channel)
         if (subscribers) {
           try {
             const payload = JSON.parse(message)
             subscribers.forEach((connection) => {
               if (!connection.isDead) {
-                connection.send({ command: "mesh/presence-update", payload })
+                connection.send({ command: "rt/presence-update", payload })
               } else {
                 subscribers.delete(connection)
               }
@@ -105,11 +105,11 @@ export class PubSubManager {
         const connection = this.connectionManager.getLocalConnection(connectionId)
         if (connection && !connection.isDead) {
           if (deleted) {
-            connection.send({ command: "mesh/record-deleted", payload: { recordId, version } })
+            connection.send({ command: "rt/record-deleted", payload: { recordId, version } })
           } else if (mode === "patch" && patch) {
-            connection.send({ command: "mesh/record-update", payload: { recordId, patch, version } })
+            connection.send({ command: "rt/record-update", payload: { recordId, patch, version } })
           } else if (mode === "full" && newValue !== undefined) {
-            connection.send({ command: "mesh/record-update", payload: { recordId, full: newValue, version } })
+            connection.send({ command: "rt/record-update", payload: { recordId, full: newValue, version } })
           }
         } else if (!connection || connection.isDead) {
           subscribers.delete(connectionId)
@@ -168,7 +168,7 @@ export class PubSubManager {
 
         const newRecords = await this.collectionManager.resolveCollection(collectionId, connection)
         const newRecordIds = newRecords.map((record) => record.id)
-        const previousRecordIdsKey = `mesh:collection:${collectionId}:${connectionId}`
+        const previousRecordIdsKey = `rt:collection:${collectionId}:${connectionId}`
         const previousRecordIdsStr = await this.pubClient.get(previousRecordIdsKey)
         const previousRecordIds = previousRecordIdsStr ? JSON.parse(previousRecordIdsStr) : []
 
@@ -199,7 +199,7 @@ export class PubSubManager {
           this.collectionManager.updateSubscriptionVersion(collectionId, connectionId, newCollectionVersion)
           await this.pubClient.set(previousRecordIdsKey, JSON.stringify(newRecordIds))
           connection.send({
-            command: "mesh/collection-diff",
+            command: "rt/collection-diff",
             payload: { collectionId, added, removed, version: newCollectionVersion },
           })
         }
@@ -209,10 +209,10 @@ export class PubSubManager {
             try {
               const { record, version } = await this.recordManager.getRecordAndVersion(recordId)
               if (record) {
-                connection.send({ command: "mesh/record-update", payload: { recordId, version, full: record } })
+                connection.send({ command: "rt/record-update", payload: { recordId, version, full: record } })
               }
             } catch (recordError) {
-              serverLogger.info(`Record ${recordId} not found during collection update (likely deleted).`)
+              serverLogger.info("record not found during collection update, likely deleted", { recordId })
             }
           }
         }
@@ -234,8 +234,8 @@ export class PubSubManager {
     if (this.subClient && this.subClient.status !== "end") {
       const channel = `${PUB_SUB_CHANNEL_PREFIX}${this.instanceId}`
       await Promise.all([
-        new Promise((resolve) => { this.subClient.unsubscribe(channel, RECORD_PUB_SUB_CHANNEL, "mesh:collection:record-change", () => resolve()) }),
-        new Promise((resolve) => { this.subClient.punsubscribe("mesh:presence:updates:*", () => resolve()) }),
+        new Promise((resolve) => { this.subClient.unsubscribe(channel, RECORD_PUB_SUB_CHANNEL, "rt:collection:record-change", () => resolve()) }),
+        new Promise((resolve) => { this.subClient.punsubscribe("rt:presence:updates:*", () => resolve()) }),
       ])
     }
   }

package/src/server/managers/records.js

@@ -65,10 +65,10 @@ export class RecordManager {
       Promise.all(
         this.recordUpdateCallbacks.map(async (callback) => {
           try { await callback({ recordId, value: finalValue }) }
-          catch (error) { serverLogger.error(`Error in record update callback for ${recordId}:`, error) }
+          catch (error) { serverLogger.error("error in record update callback", { recordId, err: error }) }
         })
       ).catch((error) => {
-        serverLogger.error(`Error in record update callbacks for ${recordId}:`, error)
+        serverLogger.error("error in record update callbacks", { recordId, err: error })
       })
     }
 
@@ -88,10 +88,10 @@ export class RecordManager {
       Promise.all(
         this.recordRemovedCallbacks.map(async (callback) => {
           try { await callback({ recordId, value: record }) }
-          catch (error) { serverLogger.error(`Error in record removed callback for ${recordId}:`, error) }
+          catch (error) { serverLogger.error("error in record removed callback", { recordId, err: error }) }
         })
       ).catch((error) => {
-        serverLogger.error(`Error in record removed callbacks for ${recordId}:`, error)
+        serverLogger.error("error in record removed callbacks", { recordId, err: error })
       })
     }
 

package/src/server/managers/rooms.js

@@ -5,9 +5,9 @@ export class RoomManager {
     this.redis = redis
   }
 
-  roomKey(roomName) { return `mesh:room:${roomName}` }
-  connectionsRoomKey(connectionId) { return `mesh:connection:${connectionId}:rooms` }
-  roomMetadataKey(roomName) { return `mesh:roommeta:${roomName}` }
+  roomKey(roomName) { return `rt:room:${roomName}` }
+  connectionsRoomKey(connectionId) { return `rt:connection:${connectionId}:rooms` }
+  roomMetadataKey(roomName) { return `rt:roommeta:${roomName}` }
 
   async getRoomConnectionIds(roomName) {
     return this.redis.smembers(this.roomKey(roomName))
@@ -30,8 +30,8 @@ export class RoomManager {
   }
 
   async getAllRooms() {
-    const keys = await this.redis.keys("mesh:room:*")
-    return keys.map((key) => key.replace("mesh:room:", ""))
+    const keys = await this.redis.keys("rt:room:*")
+    return keys.map((key) => key.replace("rt:room:", ""))
   }
 
   async removeFromRoom(roomName, connection) {
@@ -110,18 +110,18 @@ export class RoomManager {
   }
 
   async getAllMetadata() {
-    const keys = await this.redis.keys("mesh:roommeta:*")
+    const keys = await this.redis.keys("rt:roommeta:*")
     const result = []
     if (keys.length === 0) return result
     const pipeline = this.redis.pipeline()
     keys.forEach((key) => pipeline.hget(key, "data"))
     const results = await pipeline.exec()
     keys.forEach((key, index) => {
-      const roomName = key.replace("mesh:roommeta:", "")
+      const roomName = key.replace("rt:roommeta:", "")
       const data = results?.[index]?.[1]
       if (data) {
         try { result.push({ id: roomName, metadata: JSON.parse(data) }) }
-        catch (e) { serverLogger.error(`Failed to parse metadata for room ${roomName}:`, e) }
+        catch (e) { serverLogger.error("failed to parse metadata for room", { roomName, err: e }) }
       }
     })
     return result