create-fluxstack 1.14.0 → 1.16.0

package/core/server/live/LiveRoomManager.ts

@@ -1,278 +0,0 @@
-// 🔥 FluxStack Live Room Manager - Gerencia salas para LiveComponents
-
-import { roomEvents } from './RoomEventBus'
-import type { FluxStackWebSocket } from '@core/types/types'
-import { liveLog } from './LiveLogger'
-
-export interface RoomMessage {
-  type: 'ROOM_JOIN' | 'ROOM_LEAVE' | 'ROOM_EMIT' | 'ROOM_STATE_SET' | 'ROOM_STATE_GET'
-  componentId: string
-  roomId: string
-  event?: string
-  data?: any
-  requestId?: string
-  timestamp: number
-}
-
-interface RoomMember {
-  componentId: string
-  ws: FluxStackWebSocket
-  joinedAt: number
-}
-
-interface Room<TState = any> {
-  id: string
-  state: TState
-  members: Map<string, RoomMember>
-  createdAt: number
-  lastActivity: number
-}
-
-class LiveRoomManager {
-  private rooms = new Map<string, Room>()
-  private componentRooms = new Map<string, Set<string>>() // componentId -> roomIds
-
-  /**
-   * Componente entra em uma sala
-   */
-  joinRoom<TState = any>(componentId: string, roomId: string, ws: FluxStackWebSocket, initialState?: TState): { state: TState } {
-    // 🔒 Validate room name format
-    if (!roomId || !/^[a-zA-Z0-9_:.-]{1,64}$/.test(roomId)) {
-      throw new Error('Invalid room name. Must be 1-64 alphanumeric characters, hyphens, underscores, dots, or colons.')
-    }
-
-    // Criar sala se não existir
-    if (!this.rooms.has(roomId)) {
-      this.rooms.set(roomId, {
-        id: roomId,
-        state: initialState || {},
-        members: new Map(),
-        createdAt: Date.now(),
-        lastActivity: Date.now()
-      })
-      liveLog('rooms', componentId, `🏠 Room '${roomId}' created`)
-    }
-
-    const room = this.rooms.get(roomId)!
-
-    // Adicionar membro
-    room.members.set(componentId, {
-      componentId,
-      ws,
-      joinedAt: Date.now()
-    })
-    room.lastActivity = Date.now()
-
-    // Rastrear salas do componente
-    if (!this.componentRooms.has(componentId)) {
-      this.componentRooms.set(componentId, new Set())
-    }
-    this.componentRooms.get(componentId)!.add(roomId)
-
-    liveLog('rooms', componentId, `👋 Component '${componentId}' joined room '${roomId}' (${room.members.size} members)`)
-
-    // Notificar outros membros
-    this.broadcastToRoom(roomId, {
-      type: 'ROOM_SYSTEM',
-      componentId,
-      roomId,
-      event: '$sub:join',
-      data: {
-        subscriberId: componentId,
-        count: room.members.size
-      },
-      timestamp: Date.now()
-    }, componentId)
-
-    return { state: room.state }
-  }
-
-  /**
-   * Componente sai de uma sala
-   */
-  leaveRoom(componentId: string, roomId: string): void {
-    const room = this.rooms.get(roomId)
-    if (!room) return
-
-    // Remover membro
-    room.members.delete(componentId)
-    room.lastActivity = Date.now()
-
-    // Remover do rastreamento
-    this.componentRooms.get(componentId)?.delete(roomId)
-
-    liveLog('rooms', componentId, `🚶 Component '${componentId}' left room '${roomId}' (${room.members.size} members)`)
-
-    // Notificar outros membros
-    this.broadcastToRoom(roomId, {
-      type: 'ROOM_SYSTEM',
-      componentId,
-      roomId,
-      event: '$sub:leave',
-      data: {
-        subscriberId: componentId,
-        count: room.members.size
-      },
-      timestamp: Date.now()
-    })
-
-    // Cleanup sala vazia após delay
-    if (room.members.size === 0) {
-      setTimeout(() => {
-        const currentRoom = this.rooms.get(roomId)
-        if (currentRoom && currentRoom.members.size === 0) {
-          this.rooms.delete(roomId)
-          liveLog('rooms', null, `🗑️ Room '${roomId}' destroyed (empty)`)
-        }
-      }, 5 * 60 * 1000) // 5 minutos
-    }
-  }
-
-  /**
-   * Componente desconecta - sai de todas as salas
-   */
-  cleanupComponent(componentId: string): void {
-    const rooms = this.componentRooms.get(componentId)
-    if (!rooms) return
-
-    for (const roomId of rooms) {
-      this.leaveRoom(componentId, roomId)
-    }
-
-    this.componentRooms.delete(componentId)
-  }
-
-  /**
-   * Emitir evento para todos na sala
-   * - Envia via WebSocket para frontends dos outros membros
-   * - Também dispara eventos no RoomEventBus para handlers server-side
-   */
-  emitToRoom(roomId: string, event: string, data: any, excludeComponentId?: string): number {
-    const room = this.rooms.get(roomId)
-    if (!room) return 0
-
-    room.lastActivity = Date.now()
-
-    // 1. Emitir no RoomEventBus para handlers server-side (outros LiveComponents)
-    // Isso permite que componentes do servidor reajam a eventos de outros componentes
-    // Usa 'room' como tipo genérico (mesmo usado em $room.on)
-    roomEvents.emit('room', roomId, event, data, excludeComponentId)
-
-    // 2. Broadcast via WebSocket para frontends
-    return this.broadcastToRoom(roomId, {
-      type: 'ROOM_EVENT',
-      componentId: '',
-      roomId,
-      event,
-      data,
-      timestamp: Date.now()
-    }, excludeComponentId)
-  }
-
-  // 🔒 Maximum room state size (10MB) to prevent memory exhaustion attacks
-  private readonly MAX_ROOM_STATE_SIZE = 10 * 1024 * 1024
-
-  /**
-   * Atualizar estado da sala
-   */
-  setRoomState(roomId: string, updates: any, excludeComponentId?: string): void {
-    const room = this.rooms.get(roomId)
-    if (!room) return
-
-    // Merge estado
-    const newState = { ...room.state, ...updates }
-
-    // 🔒 Validate state size to prevent memory exhaustion
-    const stateSize = Buffer.byteLength(JSON.stringify(newState), 'utf8')
-    if (stateSize > this.MAX_ROOM_STATE_SIZE) {
-      throw new Error('Room state exceeds maximum size limit')
-    }
-
-    room.state = newState
-    room.lastActivity = Date.now()
-
-    // Notificar todos os membros
-    this.broadcastToRoom(roomId, {
-      type: 'ROOM_STATE',
-      componentId: '',
-      roomId,
-      event: '$state:update',
-      data: { state: updates },
-      timestamp: Date.now()
-    }, excludeComponentId)
-  }
-
-  /**
-   * Obter estado da sala
-   */
-  getRoomState<TState = any>(roomId: string): TState {
-    return (this.rooms.get(roomId)?.state || {}) as TState
-  }
-
-  /**
-   * Broadcast para todos os membros da sala
-   */
-  private broadcastToRoom(roomId: string, message: any, excludeComponentId?: string): number {
-    const room = this.rooms.get(roomId)
-    if (!room) return 0
-
-    let sent = 0
-    for (const [componentId, member] of room.members) {
-      if (excludeComponentId && componentId === excludeComponentId) continue
-
-      try {
-        if (member.ws && member.ws.readyState === 1) {
-          member.ws.send(JSON.stringify({
-            ...message,
-            componentId
-          }))
-          sent++
-        }
-      } catch (error) {
-        console.error(`Failed to send to ${componentId}:`, error)
-      }
-    }
-
-    return sent
-  }
-
-  /**
-   * Verificar se componente está em uma sala
-   */
-  isInRoom(componentId: string, roomId: string): boolean {
-    return this.rooms.get(roomId)?.members.has(componentId) ?? false
-  }
-
-  /**
-   * Obter salas de um componente
-   */
-  getComponentRooms(componentId: string): string[] {
-    return Array.from(this.componentRooms.get(componentId) || [])
-  }
-
-  /**
-   * Estatísticas
-   */
-  getStats(): {
-    totalRooms: number
-    rooms: Record<string, { members: number; createdAt: number; lastActivity: number }>
-  } {
-    const rooms: Record<string, { members: number; createdAt: number; lastActivity: number }> = {}
-
-    for (const [id, room] of this.rooms) {
-      rooms[id] = {
-        members: room.members.size,
-        createdAt: room.createdAt,
-        lastActivity: room.lastActivity
-      }
-    }
-
-    return {
-      totalRooms: this.rooms.size,
-      rooms
-    }
-  }
-}
-
-export const liveRoomManager = new LiveRoomManager()
-export type { Room, RoomMember }

package/core/server/live/RoomEventBus.ts

@@ -1,234 +0,0 @@
-// 🔥 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

@@ -1,172 +0,0 @@
-// 🔥 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 }