create-fluxstack 1.10.1 → 1.12.1

package/core/server/live/ComponentRegistry.ts

@@ -1,12 +1,13 @@
 // 🔥 FluxStack Live Components - Enhanced Component Registry
 
-import type { 
-  LiveComponent, 
-  LiveMessage, 
-  BroadcastMessage, 
+import type {
+  LiveComponent,
+  LiveMessage,
+  BroadcastMessage,
   ComponentDefinition,
-  WebSocketData 
-} from '@/core/plugins/types'
+  FluxStackWebSocket,
+  FluxStackWSData
+} from '@core/plugins/types'
 import { stateSignature, type SignedState } from './StateSignature'
 import { performanceMonitor } from './LiveComponentPerformanceMonitor'
 
@@ -65,14 +66,14 @@ export interface ServiceContainer {
 
 export class ComponentRegistry {
   private components = new Map<string, LiveComponent>()
-  private definitions = new Map<string, ComponentDefinition>()
+  private definitions = new Map<string, ComponentDefinition<any>>()
   private metadata = new Map<string, ComponentMetadata>()
   private rooms = new Map<string, Set<string>>() // roomId -> componentIds
-  private wsConnections = new Map<string, any>() // componentId -> websocket
-  private autoDiscoveredComponents = new Map<string, any>() // Auto-discovered component classes
+  private wsConnections = new Map<string, FluxStackWebSocket>() // componentId -> websocket
+  private autoDiscoveredComponents = new Map<string, new (initialState: any, ws: FluxStackWebSocket, options?: { room?: string; userId?: string }) => LiveComponent<any>>() // Auto-discovered component classes
   private dependencies = new Map<string, ComponentDependency[]>()
   private services: ServiceContainer
-  private healthCheckInterval: NodeJS.Timeout
+  private healthCheckInterval!: NodeJS.Timeout
   private recoveryStrategies = new Map<string, () => Promise<void>>()
   
   constructor() {
@@ -141,7 +142,7 @@ export class ComponentRegistry {
   }
 
   // Register component class dynamically
-  registerComponentClass(name: string, componentClass: any) {
+  registerComponentClass(name: string, componentClass: new (initialState: any, ws: FluxStackWebSocket, options?: { room?: string; userId?: string }) => LiveComponent<any>) {
     this.autoDiscoveredComponents.set(name, componentClass)
     // Logging is handled by autoDiscoverComponents
   }
@@ -151,11 +152,11 @@ export class ComponentRegistry {
     try {
       const fs = await import('fs')
       const path = await import('path')
-      const { startGroup, endGroup, logInGroup, groupSummary } = await import('@/core/utils/logger/group-logger')
+      const { startGroup, endGroup, logInGroup, groupSummary } = await import('@core/utils/logger/group-logger')
 
       if (!fs.existsSync(componentsPath)) {
         // In production, components are already bundled - no need to auto-discover
-        const { appConfig } = await import('@/config/app.config')
+        const { appConfig } = await import('@config')
         if (appConfig.env !== 'production') {
           console.log(`⚠️ Components path not found: ${componentsPath}`)
         }
@@ -215,11 +216,11 @@ export class ComponentRegistry {
 
   // Enhanced component mounting with lifecycle management
   async mountComponent(
-    ws: any, 
-    componentName: string, 
-    props: any = {},
+    ws: FluxStackWebSocket,
+    componentName: string,
+    props: Record<string, unknown> = {},
     options?: { room?: string; userId?: string; version?: string }
-  ): Promise<{ componentId: string; initialState: any; signedState: any }> {
+  ): Promise<{ componentId: string; initialState: unknown; signedState: unknown }> {
     const startTime = Date.now()
     
     try {
@@ -227,38 +228,38 @@ export class ComponentRegistry {
       await this.validateDependencies(componentName)
       
       // Try to find component definition first
-      let definition = this.definitions.get(componentName)
-      let ComponentClass: any = null
-      let initialState: any = {}
+      const definition = this.definitions.get(componentName)
+      let ComponentClass: (new (initialState: any, ws: FluxStackWebSocket, options?: { room?: string; userId?: string }) => LiveComponent<any>) | null = null
+      let initialState: Record<string, unknown> = {}
 
       if (definition) {
         // Use registered definition
-      ComponentClass = definition.component
-      initialState = definition.initialState
-    } else {
-      // Try auto-discovered components
-      ComponentClass = this.autoDiscoveredComponents.get(componentName)
-      if (!ComponentClass) {
-        // Try variations of the name
-        const variations = [
-          componentName + 'Component',
-          componentName.charAt(0).toUpperCase() + componentName.slice(1) + 'Component',
-          componentName.charAt(0).toUpperCase() + componentName.slice(1)
-        ]
-        
-        for (const variation of variations) {
-          ComponentClass = this.autoDiscoveredComponents.get(variation)
-          if (ComponentClass) break
+        ComponentClass = definition.component
+        initialState = definition.initialState as Record<string, unknown>
+      } else {
+        // Try auto-discovered components
+        ComponentClass = this.autoDiscoveredComponents.get(componentName) ?? null
+        if (!ComponentClass) {
+          // Try variations of the name
+          const variations = [
+            componentName + 'Component',
+            componentName.charAt(0).toUpperCase() + componentName.slice(1) + 'Component',
+            componentName.charAt(0).toUpperCase() + componentName.slice(1)
+          ]
+
+          for (const variation of variations) {
+            ComponentClass = this.autoDiscoveredComponents.get(variation) ?? null
+            if (ComponentClass) break
+          }
+        }
+
+        if (!ComponentClass) {
+          const availableComponents = [
+            ...Array.from(this.definitions.keys()),
+            ...Array.from(this.autoDiscoveredComponents.keys())
+          ]
+          throw new Error(`Component '${componentName}' not found. Available: ${availableComponents.join(', ')}`)
         }
-      }
-      
-      if (!ComponentClass) {
-        const availableComponents = [
-          ...Array.from(this.definitions.keys()),
-          ...Array.from(this.autoDiscoveredComponents.keys())
-        ]
-        throw new Error(`Component '${componentName}' not found. Available: ${availableComponents.join(', ')}`)
-      }
       
       // Create a default initial state for auto-discovered components
       initialState = {}
@@ -306,13 +307,16 @@ export class ComponentRegistry {
     if (!ws || typeof ws !== 'object') {
       throw new Error('Invalid WebSocket object provided')
     }
-    
+
+    // Ensure data object exists with proper structure
     if (!ws.data) {
-      ws.data = {
+      (ws as { data: FluxStackWSData }).data = {
+        connectionId: `ws-${Date.now()}`,
         components: new Map(),
         subscriptions: new Set(),
+        connectedAt: new Date(),
         userId: options?.userId
-      } as WebSocketData
+      }
     }
 
     // Ensure components map exists
@@ -358,9 +362,9 @@ export class ComponentRegistry {
   // Re-hydrate component with signed client state
   async rehydrateComponent(
     componentId: string,
-    componentName: string, 
+    componentName: string,
     signedState: SignedState,
-    ws: any,
+    ws: FluxStackWebSocket,
     options?: { room?: string; userId?: string }
   ): Promise<{ success: boolean; newComponentId?: string; error?: string }> {
     console.log('🔄 Attempting component re-hydration:', {
@@ -385,17 +389,17 @@ export class ComponentRegistry {
       }
 
       // Try to find component definition (same logic as mountComponent)
-      let definition = this.definitions.get(componentName)
-      let ComponentClass: any = null
-      let initialState: any = {}
+      const definition = this.definitions.get(componentName)
+      let ComponentClass: (new (initialState: any, ws: FluxStackWebSocket, options?: { room?: string; userId?: string }) => LiveComponent<any>) | null = null
+      let initialState: Record<string, unknown> = {}
 
       if (definition) {
         // Use registered definition
         ComponentClass = definition.component
-        initialState = definition.initialState
+        initialState = definition.initialState as Record<string, unknown>
       } else {
         // Try auto-discovered components
-        ComponentClass = this.autoDiscoveredComponents.get(componentName)
+        ComponentClass = this.autoDiscoveredComponents.get(componentName) ?? null
         if (!ComponentClass) {
           // Try variations of the name
           const variations = [
@@ -403,13 +407,13 @@ export class ComponentRegistry {
             componentName.charAt(0).toUpperCase() + componentName.slice(1) + 'Component',
             componentName.charAt(0).toUpperCase() + componentName.slice(1)
           ]
-          
+
           for (const variation of variations) {
-            ComponentClass = this.autoDiscoveredComponents.get(variation)
+            ComponentClass = this.autoDiscoveredComponents.get(variation) ?? null
             if (ComponentClass) break
           }
         }
-        
+
         if (!ComponentClass) {
           const availableComponents = [
             ...Array.from(this.definitions.keys()),
@@ -440,11 +444,13 @@ export class ComponentRegistry {
 
       // Initialize WebSocket data
       if (!ws.data) {
-        ws.data = {
+        (ws as { data: FluxStackWSData }).data = {
+          connectionId: `ws-${Date.now()}`,
           components: new Map(),
           subscriptions: new Set(),
+          connectedAt: new Date(),
           userId: options?.userId
-        } as WebSocketData
+        }
       }
 
       // Ensure components map exists
@@ -467,7 +473,8 @@ export class ComponentRegistry {
         signedState.version + 1
       )
       
-      component.emit('STATE_REHYDRATED', { 
+      // Use type assertion to access protected emit method
+      ;(component as unknown as { emit: (type: string, payload: unknown) => void }).emit('STATE_REHYDRATED', {
         state: component.getSerializableState(),
         signedState: newSignedState,
         oldComponentId: componentId,
@@ -494,8 +501,8 @@ export class ComponentRegistry {
     if (!component) return
 
     // Cleanup
-    component.destroy()
-    
+    component.destroy?.()
+
     // Remove from room subscriptions
     this.unsubscribeFromAllRooms(componentId)
     
@@ -516,7 +523,7 @@ export class ComponentRegistry {
     }
 
     try {
-      return await component.executeAction(action, payload)
+      return await component.executeAction?.(action, payload)
     } catch (error: any) {
       console.error(`❌ Error executing action '${action}' on component '${componentId}':`, error.message)
       throw error
@@ -532,7 +539,7 @@ export class ComponentRegistry {
 
     // Update state
     const updates = { [property]: value }
-    component.setState(updates)
+    component.setState?.(updates)
 
     console.log(`📝 Updated property '${property}' on component '${componentId}'`)
   }
@@ -606,7 +613,7 @@ export class ComponentRegistry {
   }
 
   // Handle WebSocket message with enhanced metrics and lifecycle tracking
-  async handleMessage(ws: any, message: LiveMessage): Promise<any> {
+  async handleMessage(ws: FluxStackWebSocket, message: LiveMessage): Promise<{ success: boolean; result?: unknown; error?: string } | null> {
     const startTime = Date.now()
     
     try {
@@ -698,7 +705,7 @@ export class ComponentRegistry {
   }
 
   // Cleanup when WebSocket disconnects
-  cleanupConnection(ws: any) {
+  cleanupConnection(ws: FluxStackWebSocket) {
     if (!ws.data?.components) return
 
     const componentsToCleanup = Array.from(ws.data.components.keys()) as string[]
@@ -926,11 +933,11 @@ export class ComponentRegistry {
     try {
       console.log(`🔄 Migrating component ${componentId} from v${fromVersion} to v${toVersion}`)
       
-      const oldState = component.getSerializableState()
+      const oldState = component.getSerializableState?.()
       const newState = migrationFn(oldState)
-      
+
       // Update component state
-      component.setState(newState)
+      component.setState?.(newState)
       
       // Record migration
       const migration: StateMigration = {
@@ -1006,7 +1013,7 @@ export class ComponentRegistry {
     
     if (component) {
       try {
-        component.destroy()
+        component.destroy?.()
       } catch (error) {
         console.error(`❌ Error destroying component ${componentId}:`, error)
       }

package/core/server/live/FileUploadManager.ts

@@ -8,7 +8,7 @@ import type {
   FileUploadCompleteMessage,
   FileUploadProgressResponse,
   FileUploadCompleteResponse
-} from '@/core/plugins/types'
+} from '@core/types/types'
 
 export class FileUploadManager {
   private activeUploads = new Map<string, ActiveUpload>()
@@ -71,7 +71,7 @@ export class FileUploadManager {
     }
   }
 
-  async receiveChunk(message: FileUploadChunkMessage, ws: any): Promise<FileUploadProgressResponse | null> {
+  async receiveChunk(message: FileUploadChunkMessage, ws: any, binaryData: Buffer | null = null): Promise<FileUploadProgressResponse | null> {
     try {
       const { uploadId, chunkIndex, totalChunks, data } = message
 
@@ -89,15 +89,23 @@ export class FileUploadManager {
       if (upload.receivedChunks.has(chunkIndex)) {
         console.log(`📦 Chunk ${chunkIndex} already received for upload ${uploadId}`)
       } else {
-        // Store chunk data
-        upload.receivedChunks.set(chunkIndex, data)
-        upload.lastChunkTime = Date.now()
+        // Store chunk data - use binary data if available, otherwise use base64 string
+        let chunkBytes: number
+
+        if (binaryData) {
+          // Binary protocol: store Buffer directly (more efficient)
+          upload.receivedChunks.set(chunkIndex, binaryData)
+          chunkBytes = binaryData.length
+        } else {
+          // JSON protocol: store base64 string (legacy support)
+          upload.receivedChunks.set(chunkIndex, data as string)
+          chunkBytes = Buffer.from(data as string, 'base64').length
+        }
 
-        // Track actual bytes received (decode base64 to get real size)
-        const chunkBytes = Buffer.from(data, 'base64').length
+        upload.lastChunkTime = Date.now()
         upload.bytesReceived += chunkBytes
 
-        console.log(`📦 Received chunk ${chunkIndex + 1}/${totalChunks} for upload ${uploadId} (${chunkBytes} bytes, total: ${upload.bytesReceived}/${upload.fileSize})`)
+        console.log(`📦 Received chunk ${chunkIndex + 1}/${totalChunks} for upload ${uploadId} (${chunkBytes} bytes, total: ${upload.bytesReceived}/${upload.fileSize})${binaryData ? ' [binary]' : ' [base64]'}`)
       }
 
       // Calculate progress based on actual bytes received (supports adaptive chunking)
@@ -213,7 +221,12 @@ export class FileUploadManager {
       for (let i = 0; i < upload.totalChunks; i++) {
         const chunkData = upload.receivedChunks.get(i)
         if (chunkData) {
-          chunks.push(Buffer.from(chunkData, 'base64'))
+          // Handle both Buffer (binary protocol) and string (base64 JSON protocol)
+          if (Buffer.isBuffer(chunkData)) {
+            chunks.push(chunkData)
+          } else {
+            chunks.push(Buffer.from(chunkData, 'base64'))
+          }
         }
       }
 
@@ -266,4 +279,4 @@ export class FileUploadManager {
 }
 
 // Global instance
-export const fileUploadManager = new FileUploadManager()
+export const fileUploadManager = new FileUploadManager()

package/core/server/live/LiveComponentPerformanceMonitor.ts

@@ -136,7 +136,7 @@ export class LiveComponentPerformanceMonitor extends EventEmitter {
   private alerts = new Map<string, PerformanceAlert[]>() // componentId -> alerts
   private suggestions = new Map<string, OptimizationSuggestion[]>()
   private config: MonitoringConfig
-  private dashboardUpdateInterval: NodeJS.Timeout
+  private dashboardUpdateInterval!: NodeJS.Timeout
   private alertCooldowns = new Map<string, number>() // alertType -> lastAlertTime
   private performanceObserver?: any
 

package/core/server/live/LiveRoomManager.ts

@@ -0,0 +1,261 @@
+// 🔥 FluxStack Live Room Manager - Gerencia salas para LiveComponents
+
+import { roomEvents } from './RoomEventBus'
+import type { FluxStackWebSocket } from '@core/types/types'
+
+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 } {
+    // 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()
+      })
+      console.log(`🏠 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)
+
+    console.log(`👋 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)
+
+    console.log(`🚶 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)
+          console.log(`🗑️ 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)
+  }
+
+  /**
+   * Atualizar estado da sala
+   */
+  setRoomState(roomId: string, updates: any, excludeComponentId?: string): void {
+    const room = this.rooms.get(roomId)
+    if (!room) return
+
+    // Merge estado
+    room.state = { ...room.state, ...updates }
+    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 }