create-fluxstack 1.12.0 → 1.13.0

package/core/server/live/auth/LiveAuthContext.ts

@@ -0,0 +1,71 @@
+// 🔒 FluxStack Live Components - Auth Context Implementation
+
+import type { LiveAuthContext, LiveAuthUser } from './types'
+
+/**
+ * Contexto de autenticação para usuários autenticados.
+ * Fornece helpers type-safe para verificação de roles e permissões.
+ *
+ * Usado internamente pelo framework - devs acessam via this.$auth no LiveComponent.
+ */
+export class AuthenticatedContext implements LiveAuthContext {
+  readonly authenticated = true
+  readonly user: LiveAuthUser
+  readonly token?: string
+  readonly authenticatedAt: number
+
+  constructor(user: LiveAuthUser, token?: string) {
+    this.user = user
+    this.token = token
+    this.authenticatedAt = Date.now()
+  }
+
+  hasRole(role: string): boolean {
+    return this.user.roles?.includes(role) ?? false
+  }
+
+  hasAnyRole(roles: string[]): boolean {
+    if (!this.user.roles?.length) return false
+    return roles.some(role => this.user.roles!.includes(role))
+  }
+
+  hasAllRoles(roles: string[]): boolean {
+    if (!this.user.roles?.length) return roles.length === 0
+    return roles.every(role => this.user.roles!.includes(role))
+  }
+
+  hasPermission(permission: string): boolean {
+    return this.user.permissions?.includes(permission) ?? false
+  }
+
+  hasAllPermissions(permissions: string[]): boolean {
+    if (!this.user.permissions?.length) return permissions.length === 0
+    return permissions.every(perm => this.user.permissions!.includes(perm))
+  }
+
+  hasAnyPermission(permissions: string[]): boolean {
+    if (!this.user.permissions?.length) return false
+    return permissions.some(perm => this.user.permissions!.includes(perm))
+  }
+}
+
+/**
+ * Contexto para usuários não autenticados (guest).
+ * Retornado quando nenhuma credencial é fornecida ou quando a auth falha.
+ */
+export class AnonymousContext implements LiveAuthContext {
+  readonly authenticated = false
+  readonly user = undefined
+  readonly token = undefined
+  readonly authenticatedAt = undefined
+
+  hasRole(): boolean { return false }
+  hasAnyRole(): boolean { return false }
+  hasAllRoles(): boolean { return false }
+  hasPermission(): boolean { return false }
+  hasAllPermissions(): boolean { return false }
+  hasAnyPermission(): boolean { return false }
+}
+
+/** Singleton para contextos anônimos (evita criar objetos desnecessários) */
+export const ANONYMOUS_CONTEXT = new AnonymousContext()

package/core/server/live/auth/LiveAuthManager.ts

@@ -0,0 +1,304 @@
+// 🔒 FluxStack Live Components - Auth Manager
+//
+// Gerencia providers de autenticação e executa verificações de auth.
+// Singleton global usado pelo ComponentRegistry e WebSocket plugin.
+
+import type {
+  LiveAuthProvider,
+  LiveAuthCredentials,
+  LiveAuthContext,
+  LiveComponentAuth,
+  LiveActionAuth,
+  LiveAuthResult,
+} from './types'
+import { AuthenticatedContext, ANONYMOUS_CONTEXT } from './LiveAuthContext'
+
+export class LiveAuthManager {
+  private providers = new Map<string, LiveAuthProvider>()
+  private defaultProviderName?: string
+
+  /**
+   * Registra um provider de autenticação.
+   *
+   * @example
+   * liveAuthManager.register(new JWTAuthProvider({ secret: 'my-secret' }))
+   * liveAuthManager.register(new CryptoAuthProvider())
+   */
+  register(provider: LiveAuthProvider): void {
+    this.providers.set(provider.name, provider)
+
+    // Primeiro provider registrado é o default
+    if (!this.defaultProviderName) {
+      this.defaultProviderName = provider.name
+    }
+
+    console.log(`🔒 Live Auth provider registered: ${provider.name}`)
+  }
+
+  /**
+   * Remove um provider de autenticação.
+   */
+  unregister(name: string): void {
+    this.providers.delete(name)
+    if (this.defaultProviderName === name) {
+      this.defaultProviderName = this.providers.keys().next().value
+    }
+  }
+
+  /**
+   * Define o provider padrão para autenticação.
+   */
+  setDefault(name: string): void {
+    if (!this.providers.has(name)) {
+      throw new Error(`Auth provider '${name}' not registered`)
+    }
+    this.defaultProviderName = name
+  }
+
+  /**
+   * Retorna true se há pelo menos um provider registrado.
+   */
+  hasProviders(): boolean {
+    return this.providers.size > 0
+  }
+
+  /**
+   * Retorna o provider padrão ou undefined se nenhum registrado.
+   */
+  getDefaultProvider(): LiveAuthProvider | undefined {
+    if (!this.defaultProviderName) return undefined
+    return this.providers.get(this.defaultProviderName)
+  }
+
+  /**
+   * Autentica credenciais usando o provider especificado, ou tenta todos os providers.
+   * Retorna ANONYMOUS_CONTEXT se nenhuma credencial é fornecida ou nenhum provider existe.
+   */
+  async authenticate(
+    credentials: LiveAuthCredentials,
+    providerName?: string
+  ): Promise<LiveAuthContext> {
+    // Sem credenciais = anônimo
+    if (!credentials || Object.keys(credentials).every(k => !credentials[k])) {
+      return ANONYMOUS_CONTEXT
+    }
+
+    // Sem providers = anônimo (auth não está configurada)
+    if (this.providers.size === 0) {
+      return ANONYMOUS_CONTEXT
+    }
+
+    // Se provider específico solicitado, usar apenas ele
+    if (providerName) {
+      const provider = this.providers.get(providerName)
+      if (!provider) {
+        console.warn(`🔒 Auth provider '${providerName}' not found`)
+        return ANONYMOUS_CONTEXT
+      }
+      try {
+        const context = await provider.authenticate(credentials)
+        return context || ANONYMOUS_CONTEXT
+      } catch (error: any) {
+        console.error(`🔒 Auth failed via '${providerName}':`, error.message)
+        return ANONYMOUS_CONTEXT
+      }
+    }
+
+    // Tentar todos os providers (default primeiro, depois os outros)
+    const providersToTry: LiveAuthProvider[] = []
+
+    // Default provider primeiro
+    if (this.defaultProviderName) {
+      const defaultProvider = this.providers.get(this.defaultProviderName)
+      if (defaultProvider) providersToTry.push(defaultProvider)
+    }
+
+    // Adicionar outros providers
+    for (const [name, provider] of this.providers) {
+      if (name !== this.defaultProviderName) {
+        providersToTry.push(provider)
+      }
+    }
+
+    // Tentar cada provider
+    for (const provider of providersToTry) {
+      try {
+        const context = await provider.authenticate(credentials)
+        if (context && context.authenticated) {
+          console.log(`🔒 Authenticated via provider: ${provider.name}`)
+          return context
+        }
+      } catch (error: any) {
+        // Silently continue to next provider
+      }
+    }
+
+    return ANONYMOUS_CONTEXT
+  }
+
+  /**
+   * Verifica se o contexto de auth atende aos requisitos do componente.
+   * Usado pelo ComponentRegistry antes de montar um componente.
+   */
+  authorizeComponent(
+    authContext: LiveAuthContext,
+    authConfig: LiveComponentAuth | undefined
+  ): LiveAuthResult {
+    // Sem config de auth = permitido
+    if (!authConfig) {
+      return { allowed: true }
+    }
+
+    // Auth required?
+    if (authConfig.required && !authContext.authenticated) {
+      return {
+        allowed: false,
+        reason: 'Authentication required'
+      }
+    }
+
+    // Verificar roles (OR logic - qualquer role basta)
+    if (authConfig.roles?.length) {
+      if (!authContext.authenticated) {
+        return {
+          allowed: false,
+          reason: `Authentication required. Roles needed: ${authConfig.roles.join(', ')}`
+        }
+      }
+      if (!authContext.hasAnyRole(authConfig.roles)) {
+        return {
+          allowed: false,
+          reason: `Insufficient roles. Required one of: ${authConfig.roles.join(', ')}`
+        }
+      }
+    }
+
+    // Verificar permissions (AND logic - todas devem estar presentes)
+    if (authConfig.permissions?.length) {
+      if (!authContext.authenticated) {
+        return {
+          allowed: false,
+          reason: `Authentication required. Permissions needed: ${authConfig.permissions.join(', ')}`
+        }
+      }
+      if (!authContext.hasAllPermissions(authConfig.permissions)) {
+        return {
+          allowed: false,
+          reason: `Insufficient permissions. Required all: ${authConfig.permissions.join(', ')}`
+        }
+      }
+    }
+
+    return { allowed: true }
+  }
+
+  /**
+   * Verifica se o contexto de auth permite executar uma action específica.
+   * Usado pelo ComponentRegistry antes de executar uma action.
+   */
+  async authorizeAction(
+    authContext: LiveAuthContext,
+    componentName: string,
+    action: string,
+    actionAuth: LiveActionAuth | undefined,
+    providerName?: string
+  ): Promise<LiveAuthResult> {
+    // Sem config de auth para esta action = permitido
+    if (!actionAuth) {
+      return { allowed: true }
+    }
+
+    // Verificar roles (OR logic)
+    if (actionAuth.roles?.length) {
+      if (!authContext.authenticated) {
+        return {
+          allowed: false,
+          reason: `Authentication required for action '${action}'`
+        }
+      }
+      if (!authContext.hasAnyRole(actionAuth.roles)) {
+        return {
+          allowed: false,
+          reason: `Insufficient roles for action '${action}'. Required one of: ${actionAuth.roles.join(', ')}`
+        }
+      }
+    }
+
+    // Verificar permissions (AND logic)
+    if (actionAuth.permissions?.length) {
+      if (!authContext.authenticated) {
+        return {
+          allowed: false,
+          reason: `Authentication required for action '${action}'`
+        }
+      }
+      if (!authContext.hasAllPermissions(actionAuth.permissions)) {
+        return {
+          allowed: false,
+          reason: `Insufficient permissions for action '${action}'. Required all: ${actionAuth.permissions.join(', ')}`
+        }
+      }
+    }
+
+    // Verificar via provider customizado (se implementado)
+    const name = providerName || this.defaultProviderName
+    if (name) {
+      const provider = this.providers.get(name)
+      if (provider?.authorizeAction) {
+        const allowed = await provider.authorizeAction(authContext, componentName, action)
+        if (!allowed) {
+          return {
+            allowed: false,
+            reason: `Action '${action}' denied by auth provider '${name}'`
+          }
+        }
+      }
+    }
+
+    return { allowed: true }
+  }
+
+  /**
+   * Verifica se o contexto de auth permite entrar em uma sala.
+   */
+  async authorizeRoom(
+    authContext: LiveAuthContext,
+    roomId: string,
+    providerName?: string
+  ): Promise<LiveAuthResult> {
+    const name = providerName || this.defaultProviderName
+    if (!name) return { allowed: true }
+
+    const provider = this.providers.get(name)
+    if (!provider?.authorizeRoom) return { allowed: true }
+
+    try {
+      const allowed = await provider.authorizeRoom(authContext, roomId)
+      if (!allowed) {
+        return {
+          allowed: false,
+          reason: `Access to room '${roomId}' denied by auth provider '${name}'`
+        }
+      }
+      return { allowed: true }
+    } catch (error: any) {
+      return {
+        allowed: false,
+        reason: `Room authorization error: ${error.message}`
+      }
+    }
+  }
+
+  /**
+   * Retorna informações sobre os providers registrados.
+   */
+  getInfo(): { providers: string[]; defaultProvider?: string } {
+    return {
+      providers: Array.from(this.providers.keys()),
+      defaultProvider: this.defaultProviderName,
+    }
+  }
+}
+
+/** Instância global do auth manager */
+export const liveAuthManager = new LiveAuthManager()

package/core/server/live/auth/index.ts

@@ -0,0 +1,19 @@
+// 🔒 FluxStack Live Components - Auth System Exports
+
+// Types
+export type {
+  LiveAuthCredentials,
+  LiveAuthUser,
+  LiveAuthContext,
+  LiveAuthProvider,
+  LiveComponentAuth,
+  LiveActionAuth,
+  LiveActionAuthMap,
+  LiveAuthResult,
+} from './types'
+
+// Context implementations
+export { AuthenticatedContext, AnonymousContext, ANONYMOUS_CONTEXT } from './LiveAuthContext'
+
+// Manager (singleton)
+export { LiveAuthManager, liveAuthManager } from './LiveAuthManager'

package/core/server/live/auth/types.ts

@@ -0,0 +1,179 @@
+// 🔒 FluxStack Live Components - Authentication Types
+//
+// Sistema declarativo de autenticação para Live Components.
+// Permite que devs configurem auth por componente e por action.
+//
+// Uso no componente:
+//   class AdminChat extends LiveComponent<State> {
+//     static auth: LiveComponentAuth = {
+//       required: true,
+//       roles: ['admin', 'moderator'],
+//     }
+//
+//     static actionAuth: LiveActionAuthMap = {
+//       deleteMessage: { permissions: ['chat.admin'] },
+//       sendMessage: { permissions: ['chat.write'] },
+//     }
+//   }
+
+// ===== Credenciais enviadas pelo cliente =====
+
+/**
+ * Credenciais enviadas pelo cliente durante a autenticação WebSocket.
+ * Extensível para suportar qualquer estratégia de auth (JWT, API key, crypto, etc.)
+ */
+export interface LiveAuthCredentials {
+  /** JWT ou token opaco */
+  token?: string
+  /** Chave pública (para crypto-auth) */
+  publicKey?: string
+  /** Assinatura (para crypto-auth) */
+  signature?: string
+  /** Timestamp da assinatura */
+  timestamp?: number
+  /** Nonce anti-replay */
+  nonce?: string
+  /** Campos adicionais para providers customizados */
+  [key: string]: unknown
+}
+
+// ===== Usuário autenticado =====
+
+/**
+ * Informações do usuário autenticado.
+ * Retornado pelo LiveAuthProvider após validação.
+ */
+export interface LiveAuthUser {
+  /** Identificador único do usuário */
+  id: string
+  /** Roles atribuídas ao usuário (ex: 'admin', 'moderator') */
+  roles?: string[]
+  /** Permissões granulares (ex: 'chat.write', 'chat.admin') */
+  permissions?: string[]
+  /** Campos adicionais (nome, email, etc.) */
+  [key: string]: unknown
+}
+
+// ===== Contexto de autenticação =====
+
+/**
+ * Contexto de autenticação disponível dentro do LiveComponent via this.$auth.
+ * Fornece helpers para verificação de roles e permissões.
+ */
+export interface LiveAuthContext {
+  /** Se o usuário está autenticado */
+  readonly authenticated: boolean
+  /** Dados do usuário (undefined se não autenticado) */
+  readonly user?: LiveAuthUser
+  /** Token original usado para autenticação */
+  readonly token?: string
+  /** Timestamp de quando a autenticação ocorreu */
+  readonly authenticatedAt?: number
+
+  /** Verifica se o usuário possui uma role específica */
+  hasRole(role: string): boolean
+  /** Verifica se o usuário possui QUALQUER uma das roles */
+  hasAnyRole(roles: string[]): boolean
+  /** Verifica se o usuário possui TODAS as roles */
+  hasAllRoles(roles: string[]): boolean
+  /** Verifica se o usuário possui uma permissão específica */
+  hasPermission(permission: string): boolean
+  /** Verifica se o usuário possui TODAS as permissões */
+  hasAllPermissions(permissions: string[]): boolean
+  /** Verifica se o usuário possui QUALQUER uma das permissões */
+  hasAnyPermission(permissions: string[]): boolean
+}
+
+// ===== Provider de autenticação =====
+
+/**
+ * Interface para implementação de estratégias de autenticação.
+ * Cada provider implementa sua própria lógica de validação.
+ *
+ * Exemplos: JWTAuthProvider, CryptoAuthProvider, SessionAuthProvider
+ */
+export interface LiveAuthProvider {
+  /** Nome único do provider (ex: 'jwt', 'crypto', 'session') */
+  readonly name: string
+
+  /**
+   * Valida credenciais e retorna contexto de autenticação.
+   * Retorna null se as credenciais forem inválidas.
+   */
+  authenticate(credentials: LiveAuthCredentials): Promise<LiveAuthContext | null>
+
+  /**
+   * (Opcional) Autorização customizada por action.
+   * Retorna true se o usuário pode executar a action.
+   * Se não implementado, usa a lógica padrão de roles/permissions.
+   */
+  authorizeAction?(
+    context: LiveAuthContext,
+    componentName: string,
+    action: string
+  ): Promise<boolean>
+
+  /**
+   * (Opcional) Autorização customizada por sala.
+   * Retorna true se o usuário pode entrar na sala.
+   */
+  authorizeRoom?(
+    context: LiveAuthContext,
+    roomId: string
+  ): Promise<boolean>
+}
+
+// ===== Configuração de auth no componente =====
+
+/**
+ * Configuração de autenticação declarativa no LiveComponent.
+ * Definida como propriedade estática na classe.
+ *
+ * @example
+ * class ProtectedChat extends LiveComponent<State> {
+ *   static auth: LiveComponentAuth = {
+ *     required: true,
+ *     roles: ['user'],
+ *     permissions: ['chat.read'],
+ *   }
+ * }
+ */
+export interface LiveComponentAuth {
+  /** Se autenticação é obrigatória para montar o componente. Default: false */
+  required?: boolean
+  /** Roles necessárias (lógica OR - qualquer uma das roles basta) */
+  roles?: string[]
+  /** Permissões necessárias (lógica AND - todas devem estar presentes) */
+  permissions?: string[]
+}
+
+/**
+ * Configuração de auth por action individual.
+ *
+ * @example
+ * static actionAuth: LiveActionAuthMap = {
+ *   deleteMessage: { permissions: ['chat.admin'] },
+ *   banUser: { roles: ['admin'] },
+ * }
+ */
+export interface LiveActionAuth {
+  /** Roles necessárias para esta action (lógica OR) */
+  roles?: string[]
+  /** Permissões necessárias para esta action (lógica AND) */
+  permissions?: string[]
+}
+
+/** Mapa de action name → configuração de auth */
+export type LiveActionAuthMap = Record<string, LiveActionAuth>
+
+// ===== Resultado de autorização =====
+
+/**
+ * Resultado de uma verificação de autorização.
+ */
+export interface LiveAuthResult {
+  /** Se a autorização foi bem-sucedida */
+  allowed: boolean
+  /** Motivo da negação (se allowed === false) */
+  reason?: string
+}

package/core/server/live/auto-generated-components.ts

@@ -1,11 +1,13 @@
 // 🔥 Auto-generated Live Components Registration
 // This file is automatically generated during build time - DO NOT EDIT MANUALLY
-// Generated at: 2026-02-09T22:13:45.496Z
+// Generated at: 2026-02-17T00:55:07.182Z
 
+import { LiveAdminPanel } from "@app/server/live/LiveAdminPanel"
 import { LiveChat } from "@app/server/live/LiveChat"
 import { LiveCounter } from "@app/server/live/LiveCounter"
 import { LiveForm } from "@app/server/live/LiveForm"
 import { LiveLocalCounter } from "@app/server/live/LiveLocalCounter"
+import { LiveProtectedChat } from "@app/server/live/LiveProtectedChat"
 import { LiveRoomChat } from "@app/server/live/LiveRoomChat"
 import { LiveUpload } from "@app/server/live/LiveUpload"
 import { componentRegistry } from "@core/server/live/ComponentRegistry"
@@ -14,14 +16,16 @@ import { componentRegistry } from "@core/server/live/ComponentRegistry"
 function registerAllComponents() {
   try {
     // Auto-generated component registrations
+    componentRegistry.registerComponentClass('LiveAdminPanel', LiveAdminPanel)
     componentRegistry.registerComponentClass('LiveChat', LiveChat)
     componentRegistry.registerComponentClass('LiveCounter', LiveCounter)
     componentRegistry.registerComponentClass('LiveForm', LiveForm)
     componentRegistry.registerComponentClass('LiveLocalCounter', LiveLocalCounter)
+    componentRegistry.registerComponentClass('LiveProtectedChat', LiveProtectedChat)
     componentRegistry.registerComponentClass('LiveRoomChat', LiveRoomChat)
     componentRegistry.registerComponentClass('LiveUpload', LiveUpload)
     
-    console.log('📝 Live components registered successfully! (6 components)')
+    console.log('📝 Live components registered successfully! (8 components)')
   } catch (error) {
     console.warn('⚠️ Error registering components:', error)
   }
@@ -32,10 +36,12 @@ registerAllComponents()
 
 // Export all components to ensure they're included in the bundle
 export { 
+  LiveAdminPanel,
   LiveChat,
   LiveCounter,
   LiveForm,
   LiveLocalCounter,
+  LiveProtectedChat,
   LiveRoomChat,
   LiveUpload
 }

package/core/server/live/index.ts

@@ -12,3 +12,19 @@ export { connectionManager } from './WebSocketConnectionManager'
 export { fileUploadManager } from './FileUploadManager'
 export { stateSignature } from './StateSignature'
 export { performanceMonitor } from './LiveComponentPerformanceMonitor'
+export { liveLog, liveWarn, registerComponentLogging, unregisterComponentLogging } from './LiveLogger'
+export type { LiveLogCategory, LiveLogConfig } from './LiveLogger'
+
+// 🔒 Auth system
+export { liveAuthManager, LiveAuthManager } from './auth/LiveAuthManager'
+export { AuthenticatedContext, AnonymousContext, ANONYMOUS_CONTEXT } from './auth/LiveAuthContext'
+export type {
+  LiveAuthProvider,
+  LiveAuthCredentials,
+  LiveAuthUser,
+  LiveAuthContext,
+  LiveComponentAuth,
+  LiveActionAuth,
+  LiveActionAuthMap,
+  LiveAuthResult,
+} from './auth/types'