create-fluxstack 1.10.1 → 1.12.0

package/core/server/live/RoomEventBus.ts

@@ -0,0 +1,234 @@
+// 🔥 FluxStack Live - Room Event Bus (Pub/Sub server-side)
+
+type EventHandler<T = any> = (data: T) => void
+
+interface RoomSubscription {
+  roomType: string
+  roomId: string
+  event: string
+  handler: EventHandler
+  componentId: string
+}
+
+export function createTypedRoomEventBus<TRoomEvents extends Record<string, Record<string, any>>>() {
+  const subscriptions = new Map<string, Set<RoomSubscription>>()
+
+  const getKey = (roomType: string, roomId: string, event: string) =>
+    `${roomType}:${roomId}:${event}`
+
+  const getRoomKey = (roomType: string, roomId: string) =>
+    `${roomType}:${roomId}`
+
+  return {
+    on<K extends keyof TRoomEvents, E extends keyof TRoomEvents[K]>(
+      roomType: K,
+      roomId: string,
+      event: E,
+      componentId: string,
+      handler: EventHandler<TRoomEvents[K][E]>
+    ): () => void {
+      const key = getKey(roomType as string, roomId, event as string)
+
+      if (!subscriptions.has(key)) {
+        subscriptions.set(key, new Set())
+      }
+
+      const subscription: RoomSubscription = {
+        roomType: roomType as string,
+        roomId,
+        event: event as string,
+        handler,
+        componentId
+      }
+
+      subscriptions.get(key)!.add(subscription)
+
+      return () => {
+        subscriptions.get(key)?.delete(subscription)
+        if (subscriptions.get(key)?.size === 0) {
+          subscriptions.delete(key)
+        }
+      }
+    },
+
+    emit<K extends keyof TRoomEvents, E extends keyof TRoomEvents[K]>(
+      roomType: K,
+      roomId: string,
+      event: E,
+      data: TRoomEvents[K][E],
+      excludeComponentId?: string
+    ): number {
+      const key = getKey(roomType as string, roomId, event as string)
+      const subs = subscriptions.get(key)
+
+      if (!subs || subs.size === 0) return 0
+
+      let notified = 0
+      for (const sub of subs) {
+        if (excludeComponentId && sub.componentId === excludeComponentId) continue
+
+        try {
+          sub.handler(data)
+          notified++
+        } catch (error) {
+          console.error(`❌ RoomEventBus error [${key}]:`, error)
+        }
+      }
+
+      return notified
+    },
+
+    unsubscribeAll(componentId: string): number {
+      let removed = 0
+
+      for (const [key, subs] of subscriptions) {
+        for (const sub of subs) {
+          if (sub.componentId === componentId) {
+            subs.delete(sub)
+            removed++
+          }
+        }
+        if (subs.size === 0) {
+          subscriptions.delete(key)
+        }
+      }
+
+      return removed
+    },
+
+    clearRoom<K extends keyof TRoomEvents>(roomType: K, roomId: string): number {
+      const prefix = getRoomKey(roomType as string, roomId)
+      let removed = 0
+
+      for (const key of subscriptions.keys()) {
+        if (key.startsWith(prefix)) {
+          removed += subscriptions.get(key)?.size ?? 0
+          subscriptions.delete(key)
+        }
+      }
+
+      return removed
+    },
+
+    getStats(): { totalSubscriptions: number; rooms: Record<string, { events: Record<string, number> }> } {
+      const rooms: Record<string, { events: Record<string, number> }> = {}
+      let total = 0
+
+      for (const [key, subs] of subscriptions) {
+        const [roomType, roomId, event] = key.split(':')
+        const roomKey = `${roomType}:${roomId}`
+
+        if (!rooms[roomKey]) {
+          rooms[roomKey] = { events: {} }
+        }
+
+        rooms[roomKey].events[event] = subs.size
+        total += subs.size
+      }
+
+      return { totalSubscriptions: total, rooms }
+    }
+  }
+}
+
+class RoomEventBus {
+  private subscriptions = new Map<string, Set<RoomSubscription>>()
+
+  private getKey(roomType: string, roomId: string, event: string): string {
+    return `${roomType}:${roomId}:${event}`
+  }
+
+  on(roomType: string, roomId: string, event: string, componentId: string, handler: EventHandler): () => void {
+    const key = this.getKey(roomType, roomId, event)
+
+    if (!this.subscriptions.has(key)) {
+      this.subscriptions.set(key, new Set())
+    }
+
+    const subscription: RoomSubscription = { roomType, roomId, event, handler, componentId }
+    this.subscriptions.get(key)!.add(subscription)
+
+    return () => {
+      this.subscriptions.get(key)?.delete(subscription)
+      if (this.subscriptions.get(key)?.size === 0) {
+        this.subscriptions.delete(key)
+      }
+    }
+  }
+
+  emit(roomType: string, roomId: string, event: string, data: any, excludeComponentId?: string): number {
+    const key = this.getKey(roomType, roomId, event)
+    const subs = this.subscriptions.get(key)
+
+    if (!subs || subs.size === 0) return 0
+
+    let notified = 0
+    for (const sub of subs) {
+      if (excludeComponentId && sub.componentId === excludeComponentId) continue
+
+      try {
+        sub.handler(data)
+        notified++
+      } catch (error) {
+        console.error(`❌ RoomEventBus error [${key}]:`, error)
+      }
+    }
+
+    return notified
+  }
+
+  unsubscribeAll(componentId: string): number {
+    let removed = 0
+
+    for (const [key, subs] of this.subscriptions) {
+      for (const sub of subs) {
+        if (sub.componentId === componentId) {
+          subs.delete(sub)
+          removed++
+        }
+      }
+      if (subs.size === 0) {
+        this.subscriptions.delete(key)
+      }
+    }
+
+    return removed
+  }
+
+  clearRoom(roomType: string, roomId: string): number {
+    const prefix = `${roomType}:${roomId}`
+    let removed = 0
+
+    for (const key of this.subscriptions.keys()) {
+      if (key.startsWith(prefix)) {
+        removed += this.subscriptions.get(key)?.size ?? 0
+        this.subscriptions.delete(key)
+      }
+    }
+
+    return removed
+  }
+
+  getStats() {
+    const rooms: Record<string, { events: Record<string, number> }> = {}
+    let total = 0
+
+    for (const [key, subs] of this.subscriptions) {
+      const [roomType, roomId, event] = key.split(':')
+      const roomKey = `${roomType}:${roomId}`
+
+      if (!rooms[roomKey]) {
+        rooms[roomKey] = { events: {} }
+      }
+
+      rooms[roomKey].events[event] = subs.size
+      total += subs.size
+    }
+
+    return { totalSubscriptions: total, rooms }
+  }
+}
+
+export const roomEvents = new RoomEventBus()
+
+export type { EventHandler, RoomSubscription }

package/core/server/live/RoomStateManager.ts

@@ -0,0 +1,172 @@
+// 🔥 FluxStack Live - Room State Manager (In-memory storage per room)
+
+type RoomStateData = Record<string, any>
+
+interface RoomInfo {
+  state: RoomStateData
+  componentCount: number
+  createdAt: number
+  lastUpdate: number
+}
+
+export function createTypedRoomState<TRoomTypes extends Record<string, RoomStateData>>() {
+  const rooms = new Map<string, RoomInfo>()
+  const getKey = (type: string, roomId: string) => `${type}:${roomId}`
+
+  return {
+    get<K extends keyof TRoomTypes>(type: K, roomId: string, defaultState: TRoomTypes[K]): TRoomTypes[K] {
+      const key = getKey(type as string, roomId)
+      const room = rooms.get(key)
+
+      if (room) return room.state as TRoomTypes[K]
+
+      rooms.set(key, { state: defaultState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() })
+      return defaultState
+    },
+
+    update<K extends keyof TRoomTypes>(type: K, roomId: string, updates: Partial<TRoomTypes[K]>): TRoomTypes[K] {
+      const key = getKey(type as string, roomId)
+      const room = rooms.get(key)
+
+      if (room) {
+        room.state = { ...room.state, ...updates }
+        room.lastUpdate = Date.now()
+        return room.state as TRoomTypes[K]
+      }
+
+      const newState = updates as TRoomTypes[K]
+      rooms.set(key, { state: newState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() })
+      return newState
+    },
+
+    set<K extends keyof TRoomTypes>(type: K, roomId: string, state: TRoomTypes[K]): void {
+      const key = getKey(type as string, roomId)
+      const room = rooms.get(key)
+
+      if (room) {
+        room.state = state
+        room.lastUpdate = Date.now()
+      } else {
+        rooms.set(key, { state, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() })
+      }
+    },
+
+    join<K extends keyof TRoomTypes>(type: K, roomId: string): void {
+      const room = rooms.get(getKey(type as string, roomId))
+      if (room) room.componentCount++
+    },
+
+    leave<K extends keyof TRoomTypes>(type: K, roomId: string): void {
+      const key = getKey(type as string, roomId)
+      const room = rooms.get(key)
+      if (room) {
+        room.componentCount--
+        if (room.componentCount <= 0) {
+          setTimeout(() => {
+            const current = rooms.get(key)
+            if (current && current.componentCount <= 0) {
+              rooms.delete(key)
+            }
+          }, 5 * 60 * 1000)
+        }
+      }
+    },
+
+    has<K extends keyof TRoomTypes>(type: K, roomId: string): boolean {
+      return rooms.has(getKey(type as string, roomId))
+    },
+
+    delete<K extends keyof TRoomTypes>(type: K, roomId: string): boolean {
+      return rooms.delete(getKey(type as string, roomId))
+    },
+
+    getStats(): { totalRooms: number; rooms: Record<string, { componentCount: number; stateKeys: string[] }> } {
+      const roomStats: Record<string, { componentCount: number; stateKeys: string[] }> = {}
+      for (const [key, info] of rooms) {
+        roomStats[key] = { componentCount: info.componentCount, stateKeys: Object.keys(info.state) }
+      }
+      return { totalRooms: rooms.size, rooms: roomStats }
+    }
+  }
+}
+
+class RoomStateManager {
+  private rooms = new Map<string, RoomInfo>()
+
+  get<T extends RoomStateData>(roomId: string, defaultState?: T): T {
+    const room = this.rooms.get(roomId)
+    if (room) return room.state as T
+
+    if (defaultState) {
+      this.rooms.set(roomId, { state: defaultState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() })
+      return defaultState
+    }
+
+    return {} as T
+  }
+
+  update<T extends RoomStateData>(roomId: string, updates: Partial<T>): T {
+    const room = this.rooms.get(roomId)
+
+    if (room) {
+      room.state = { ...room.state, ...updates }
+      room.lastUpdate = Date.now()
+      return room.state as T
+    }
+
+    const newState = updates as T
+    this.rooms.set(roomId, { state: newState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() })
+    return newState
+  }
+
+  set<T extends RoomStateData>(roomId: string, state: T): void {
+    const room = this.rooms.get(roomId)
+
+    if (room) {
+      room.state = state
+      room.lastUpdate = Date.now()
+    } else {
+      this.rooms.set(roomId, { state, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() })
+    }
+  }
+
+  join(roomId: string): void {
+    const room = this.rooms.get(roomId)
+    if (room) room.componentCount++
+  }
+
+  leave(roomId: string): void {
+    const room = this.rooms.get(roomId)
+    if (room) {
+      room.componentCount--
+      if (room.componentCount <= 0) {
+        setTimeout(() => {
+          const current = this.rooms.get(roomId)
+          if (current && current.componentCount <= 0) {
+            this.rooms.delete(roomId)
+          }
+        }, 5 * 60 * 1000)
+      }
+    }
+  }
+
+  has(roomId: string): boolean {
+    return this.rooms.has(roomId)
+  }
+
+  delete(roomId: string): boolean {
+    return this.rooms.delete(roomId)
+  }
+
+  getStats(): { totalRooms: number; rooms: Record<string, { componentCount: number; stateKeys: string[] }> } {
+    const rooms: Record<string, { componentCount: number; stateKeys: string[] }> = {}
+    for (const [roomId, info] of this.rooms) {
+      rooms[roomId] = { componentCount: info.componentCount, stateKeys: Object.keys(info.state) }
+    }
+    return { totalRooms: this.rooms.size, rooms }
+  }
+}
+
+export const roomState = new RoomStateManager()
+
+export type { RoomStateData, RoomInfo }