create-fluxstack 1.12.1 → 1.14.0

package/core/build/optimizer.ts

@@ -1,236 +1,236 @@
-import { readFileSync, writeFileSync, statSync, readdirSync } from "fs"
-import { join, extname } from "path"
-import { gzipSync } from "zlib"
-import type { OptimizationConfig, OptimizationResult } from "../types/build"
-import { buildLogger } from "../utils/build-logger"
-
-export interface OptimizerConfig {
-  treeshake: boolean
-  compress: boolean
-  removeUnusedCSS: boolean
-  optimizeImages: boolean
-  bundleAnalysis: boolean
-}
-
-export class Optimizer {
-  private config: OptimizerConfig
-
-  constructor(config: OptimizerConfig) {
-    this.config = config
-  }
-
-  async optimize(buildPath: string): Promise<OptimizationResult> {
-    buildLogger.section('Build Optimization', '🔧')
-
-    const startTime = Date.now()
-    const results: OptimizationResult = {
-      success: true,
-      duration: 0,
-      originalSize: 0,
-      optimizedSize: 0,
-      compressionRatio: 0,
-      optimizations: []
-    }
-
-    try {
-      // Get original size
-      results.originalSize = await this.calculateDirectorySize(buildPath)
-      buildLogger.step(`Original size: ${buildLogger.formatSize(results.originalSize)}`)
-
-      // Apply optimizations (minification removed for compatibility)
-
-      if (this.config.compress) {
-        await this.compressAssets(buildPath, results)
-      }
-
-      if (this.config.removeUnusedCSS) {
-        await this.removeUnusedCSS(buildPath, results)
-      }
-
-      if (this.config.optimizeImages) {
-        await this.optimizeImages(buildPath, results)
-      }
-
-      if (this.config.bundleAnalysis) {
-        await this.analyzeBundles(buildPath, results)
-      }
-
-      // Calculate final size and compression ratio
-      results.optimizedSize = await this.calculateDirectorySize(buildPath)
-      results.compressionRatio = results.originalSize > 0
-        ? ((results.originalSize - results.optimizedSize) / results.originalSize) * 100
-        : 0
-
-      results.duration = Date.now() - startTime
-
-      buildLogger.success(`Optimization completed in ${buildLogger.formatDuration(results.duration)}`)
-
-      // Create optimization summary table
-      const optimizationData = results.optimizations.map(opt => ({
-        type: opt.type,
-        description: opt.description,
-        saved: buildLogger.formatSize(opt.sizeSaved)
-      }))
-
-      if (optimizationData.length > 0) {
-        buildLogger.table(
-          [
-            { header: 'Optimization', key: 'type', width: 20, align: 'left', color: 'cyan' },
-            { header: 'Description', key: 'description', width: 35, align: 'left' },
-            { header: 'Size Saved', key: 'saved', width: 12, align: 'right', color: 'green' }
-          ],
-          optimizationData
-        )
-      }
-
-      return results
-
-    } catch (error) {
-      results.success = false
-      results.duration = Date.now() - startTime
-      results.error = error instanceof Error ? error.message : "Unknown optimization error"
-
-      buildLogger.error(`Optimization failed: ${results.error}`)
-      return results
-    }
-  }
-
-  // Minification methods removed for compatibility with Bun bundler
-
-  private async compressAssets(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Compressing assets...")
-
-    const files = this.getFilesRecursively(buildPath)
-    let compressedCount = 0
-
-    for (const file of files) {
-      const ext = extname(file).toLowerCase()
-      
-      if (['.js', '.css', '.html', '.json', '.svg'].includes(ext)) {
-        try {
-          const content = readFileSync(file)
-          const compressed = gzipSync(content)
-          
-          // Only create .gz file if it's significantly smaller
-          if (compressed.length < content.length * 0.9) {
-            writeFileSync(file + '.gz', compressed)
-            compressedCount++
-          }
-        } catch (error) {
-          // Silently skip files that can't be compressed
-        }
-      }
-    }
-
-    buildLogger.success(`Compressed ${compressedCount} files`)
-    results.optimizations.push({
-      type: 'compression',
-      description: `Created gzip versions for ${compressedCount} files`,
-      sizeSaved: 0
-    })
-  }
-
-  private async removeUnusedCSS(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Analyzing CSS...")
-
-    // This is a placeholder - real implementation would use PurgeCSS or similar
-    results.optimizations.push({
-      type: 'css-purging',
-      description: 'CSS purging not implemented yet',
-      sizeSaved: 0
-    })
-  }
-
-  private async optimizeImages(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Optimizing images...")
-
-    // This is a placeholder - real implementation would use imagemin or similar
-    results.optimizations.push({
-      type: 'image-optimization',
-      description: 'Image optimization not implemented yet',
-      sizeSaved: 0
-    })
-  }
-
-  private async analyzeBundles(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Analyzing bundles...")
-    
-    const files = this.getFilesRecursively(buildPath)
-    const jsFiles = files.filter(f => extname(f) === '.js')
-    
-    let totalJSSize = 0
-    for (const file of jsFiles) {
-      totalJSSize += statSync(file).size
-    }
-
-    results.optimizations.push({
-      type: 'bundle-analysis',
-      description: `Analyzed ${jsFiles.length} JS bundles (${(totalJSSize / 1024).toFixed(2)} KB total)`,
-      sizeSaved: 0
-    })
-  }
-
-  private async calculateDirectorySize(dirPath: string): Promise<number> {
-    const files = this.getFilesRecursively(dirPath)
-    let totalSize = 0
-    
-    for (const file of files) {
-      try {
-        totalSize += statSync(file).size
-      } catch (error) {
-        // Ignore files that can't be read
-      }
-    }
-    
-    return totalSize
-  }
-
-  private getFilesRecursively(dir: string): string[] {
-    const files: string[] = []
-    
-    try {
-      const items = readdirSync(dir, { withFileTypes: true })
-      
-      for (const item of items) {
-        const fullPath = join(dir, item.name)
-        
-        if (item.isDirectory()) {
-          files.push(...this.getFilesRecursively(fullPath))
-        } else {
-          files.push(fullPath)
-        }
-      }
-    } catch (error) {
-      // Ignore directories that can't be read
-    }
-    
-    return files
-  }
-
-  async createOptimizationReport(result: OptimizationResult): Promise<string> {
-    const report = `
-# Build Optimization Report
-
-## Summary
-- **Status**: ${result.success ? '✅ Success' : '❌ Failed'}
-- **Duration**: ${result.duration}ms
-- **Original Size**: ${(result.originalSize / 1024).toFixed(2)} KB
-- **Optimized Size**: ${(result.optimizedSize / 1024).toFixed(2)} KB
-- **Size Reduction**: ${result.compressionRatio.toFixed(2)}%
-
-## Optimizations Applied
-
-${result.optimizations.map(opt => 
-  `### ${opt.type.charAt(0).toUpperCase() + opt.type.slice(1)}
-- ${opt.description}
-- Size Saved: ${(opt.sizeSaved / 1024).toFixed(2)} KB`
-).join('\n\n')}
-
-${result.error ? `## Error\n${result.error}` : ''}
-
-Generated at: ${new Date().toISOString()}
-`
-
-    return report.trim()
-  }
+import { readFileSync, writeFileSync, statSync, readdirSync } from "fs"
+import { join, extname } from "path"
+import { gzipSync } from "zlib"
+import type { OptimizationConfig, OptimizationResult } from "../types/build"
+import { buildLogger } from "../utils/build-logger"
+
+export interface OptimizerConfig {
+  treeshake: boolean
+  compress: boolean
+  removeUnusedCSS: boolean
+  optimizeImages: boolean
+  bundleAnalysis: boolean
+}
+
+export class Optimizer {
+  private config: OptimizerConfig
+
+  constructor(config: OptimizerConfig) {
+    this.config = config
+  }
+
+  async optimize(buildPath: string): Promise<OptimizationResult> {
+    buildLogger.section('Build Optimization', '🔧')
+
+    const startTime = Date.now()
+    const results: OptimizationResult = {
+      success: true,
+      duration: 0,
+      originalSize: 0,
+      optimizedSize: 0,
+      compressionRatio: 0,
+      optimizations: []
+    }
+
+    try {
+      // Get original size
+      results.originalSize = await this.calculateDirectorySize(buildPath)
+      buildLogger.step(`Original size: ${buildLogger.formatSize(results.originalSize)}`)
+
+      // Apply optimizations (minification removed for compatibility)
+
+      if (this.config.compress) {
+        await this.compressAssets(buildPath, results)
+      }
+
+      if (this.config.removeUnusedCSS) {
+        await this.removeUnusedCSS(buildPath, results)
+      }
+
+      if (this.config.optimizeImages) {
+        await this.optimizeImages(buildPath, results)
+      }
+
+      if (this.config.bundleAnalysis) {
+        await this.analyzeBundles(buildPath, results)
+      }
+
+      // Calculate final size and compression ratio
+      results.optimizedSize = await this.calculateDirectorySize(buildPath)
+      results.compressionRatio = results.originalSize > 0
+        ? ((results.originalSize - results.optimizedSize) / results.originalSize) * 100
+        : 0
+
+      results.duration = Date.now() - startTime
+
+      buildLogger.success(`Optimization completed in ${buildLogger.formatDuration(results.duration)}`)
+
+      // Create optimization summary table
+      const optimizationData = results.optimizations.map(opt => ({
+        type: opt.type,
+        description: opt.description,
+        saved: buildLogger.formatSize(opt.sizeSaved)
+      }))
+
+      if (optimizationData.length > 0) {
+        buildLogger.table(
+          [
+            { header: 'Optimization', key: 'type', width: 20, align: 'left', color: 'cyan' },
+            { header: 'Description', key: 'description', width: 35, align: 'left' },
+            { header: 'Size Saved', key: 'saved', width: 12, align: 'right', color: 'green' }
+          ],
+          optimizationData
+        )
+      }
+
+      return results
+
+    } catch (error) {
+      results.success = false
+      results.duration = Date.now() - startTime
+      results.error = error instanceof Error ? error.message : "Unknown optimization error"
+
+      buildLogger.error(`Optimization failed: ${results.error}`)
+      return results
+    }
+  }
+
+  // Minification methods removed for compatibility with Bun bundler
+
+  private async compressAssets(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Compressing assets...")
+
+    const files = this.getFilesRecursively(buildPath)
+    let compressedCount = 0
+
+    for (const file of files) {
+      const ext = extname(file).toLowerCase()
+      
+      if (['.js', '.css', '.html', '.json', '.svg'].includes(ext)) {
+        try {
+          const content = readFileSync(file)
+          const compressed = gzipSync(content)
+          
+          // Only create .gz file if it's significantly smaller
+          if (compressed.length < content.length * 0.9) {
+            writeFileSync(file + '.gz', compressed)
+            compressedCount++
+          }
+        } catch (error) {
+          // Silently skip files that can't be compressed
+        }
+      }
+    }
+
+    buildLogger.success(`Compressed ${compressedCount} files`)
+    results.optimizations.push({
+      type: 'compression',
+      description: `Created gzip versions for ${compressedCount} files`,
+      sizeSaved: 0
+    })
+  }
+
+  private async removeUnusedCSS(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Analyzing CSS...")
+
+    // This is a placeholder - real implementation would use PurgeCSS or similar
+    results.optimizations.push({
+      type: 'css-purging',
+      description: 'CSS purging not implemented yet',
+      sizeSaved: 0
+    })
+  }
+
+  private async optimizeImages(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Optimizing images...")
+
+    // This is a placeholder - real implementation would use imagemin or similar
+    results.optimizations.push({
+      type: 'image-optimization',
+      description: 'Image optimization not implemented yet',
+      sizeSaved: 0
+    })
+  }
+
+  private async analyzeBundles(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Analyzing bundles...")
+    
+    const files = this.getFilesRecursively(buildPath)
+    const jsFiles = files.filter(f => extname(f) === '.js')
+    
+    let totalJSSize = 0
+    for (const file of jsFiles) {
+      totalJSSize += statSync(file).size
+    }
+
+    results.optimizations.push({
+      type: 'bundle-analysis',
+      description: `Analyzed ${jsFiles.length} JS bundles (${(totalJSSize / 1024).toFixed(2)} KB total)`,
+      sizeSaved: 0
+    })
+  }
+
+  private async calculateDirectorySize(dirPath: string): Promise<number> {
+    const files = this.getFilesRecursively(dirPath)
+    let totalSize = 0
+    
+    for (const file of files) {
+      try {
+        totalSize += statSync(file).size
+      } catch (error) {
+        // Ignore files that can't be read
+      }
+    }
+    
+    return totalSize
+  }
+
+  private getFilesRecursively(dir: string): string[] {
+    const files: string[] = []
+    
+    try {
+      const items = readdirSync(dir, { withFileTypes: true })
+      
+      for (const item of items) {
+        const fullPath = join(dir, item.name)
+        
+        if (item.isDirectory()) {
+          files.push(...this.getFilesRecursively(fullPath))
+        } else {
+          files.push(fullPath)
+        }
+      }
+    } catch (error) {
+      // Ignore directories that can't be read
+    }
+    
+    return files
+  }
+
+  async createOptimizationReport(result: OptimizationResult): Promise<string> {
+    const report = `
+# Build Optimization Report
+
+## Summary
+- **Status**: ${result.success ? '✅ Success' : '❌ Failed'}
+- **Duration**: ${result.duration}ms
+- **Original Size**: ${(result.originalSize / 1024).toFixed(2)} KB
+- **Optimized Size**: ${(result.optimizedSize / 1024).toFixed(2)} KB
+- **Size Reduction**: ${result.compressionRatio.toFixed(2)}%
+
+## Optimizations Applied
+
+${result.optimizations.map(opt => 
+  `### ${opt.type.charAt(0).toUpperCase() + opt.type.slice(1)}
+- ${opt.description}
+- Size Saved: ${(opt.sizeSaved / 1024).toFixed(2)} KB`
+).join('\n\n')}
+
+${result.error ? `## Error\n${result.error}` : ''}
+
+Generated at: ${new Date().toISOString()}
+`
+
+    return report.trim()
+  }
 }

package/core/client/LiveComponentsProvider.tsx

@@ -4,11 +4,23 @@
 import React, { createContext, useContext, useEffect, useRef, useState, useCallback } from 'react'
 import type { WebSocketMessage, WebSocketResponse } from '../types/types'
 
+/** Auth credentials to send during WebSocket connection */
+export interface LiveAuthOptions {
+  /** JWT or opaque token */
+  token?: string
+  /** Provider name (if multiple auth providers configured) */
+  provider?: string
+  /** Additional credentials (publicKey, signature, etc.) */
+  [key: string]: unknown
+}
+
 export interface LiveComponentsContextValue {
   connected: boolean
   connecting: boolean
   error: string | null
   connectionId: string | null
+  /** Whether the WebSocket connection is authenticated */
+  authenticated: boolean
 
   // Send message without waiting for response
   sendMessage: (message: WebSocketMessage) => Promise<void>
@@ -28,6 +40,9 @@ export interface LiveComponentsContextValue {
   // Manual reconnect
   reconnect: () => void
 
+  // Authenticate (or re-authenticate) the WebSocket connection
+  authenticate: (credentials: LiveAuthOptions) => Promise<boolean>
+
   // Get current WebSocket instance (for advanced use)
   getWebSocket: () => WebSocket | null
 }
@@ -37,6 +52,8 @@ const LiveComponentsContext = createContext<LiveComponentsContextValue | null>(n
 export interface LiveComponentsProviderProps {
   children: React.ReactNode
   url?: string
+  /** Auth credentials to send on connection */
+  auth?: LiveAuthOptions
   autoConnect?: boolean
   reconnectInterval?: number
   maxReconnectAttempts?: number
@@ -47,6 +64,7 @@ export interface LiveComponentsProviderProps {
 export function LiveComponentsProvider({
   children,
   url,
+  auth,
   autoConnect = true,
   reconnectInterval = 1000,
   maxReconnectAttempts = 5,
@@ -56,12 +74,23 @@ export function LiveComponentsProvider({
 
   // Get WebSocket URL dynamically
   const getWebSocketUrl = () => {
-    if (url) return url
-    if (typeof window === 'undefined') return 'ws://localhost:3000/api/live/ws'
+    let baseUrl: string
+    if (url) {
+      baseUrl = url
+    } else if (typeof window === 'undefined') {
+      baseUrl = 'ws://localhost:3000/api/live/ws'
+    } else {
+      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+      baseUrl = `${protocol}//${window.location.host}/api/live/ws`
+    }
 
-    // Always use current host - works for both dev and production
-    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
-    return `${protocol}//${window.location.host}/api/live/ws`
+    // Append auth token as query param if provided
+    if (auth?.token) {
+      const separator = baseUrl.includes('?') ? '&' : '?'
+      return `${baseUrl}${separator}token=${encodeURIComponent(auth.token)}`
+    }
+
+    return baseUrl
   }
 
   const wsUrl = getWebSocketUrl()
@@ -71,6 +100,7 @@ export function LiveComponentsProvider({
   const [connecting, setConnecting] = useState(false)
   const [error, setError] = useState<string | null>(null)
   const [connectionId, setConnectionId] = useState<string | null>(null)
+  const [authenticated, setAuthenticated] = useState(false)
 
   // Refs
   const wsRef = useRef<WebSocket | null>(null)
@@ -136,7 +166,30 @@ export function LiveComponentsProvider({
           // Handle connection established
           if (response.type === 'CONNECTION_ESTABLISHED') {
             setConnectionId(response.connectionId || null)
+            setAuthenticated((response as any).authenticated || false)
             log('🔗 Connection ID:', response.connectionId)
+            if ((response as any).authenticated) {
+              log('🔒 Authenticated as:', (response as any).userId)
+            }
+
+            // If auth credentials provided but not yet authenticated via query,
+            // send AUTH message with full credentials
+            if (auth && !auth.token && Object.keys(auth).some(k => auth[k])) {
+              sendMessageAndWait({
+                type: 'AUTH',
+                payload: auth
+              } as any).then(authResp => {
+                if ((authResp as any).authenticated) {
+                  setAuthenticated(true)
+                  log('🔒 Authenticated via message')
+                }
+              }).catch(() => {})
+            }
+          }
+
+          // Handle auth response
+          if (response.type === 'AUTH_RESPONSE') {
+            setAuthenticated((response as any).authenticated || false)
           }
 
           // Handle pending requests (request-response pattern)
@@ -403,6 +456,22 @@ export function LiveComponentsProvider({
     log('🗑️ Component unregistered', componentId)
   }, [log])
 
+  // Authenticate (or re-authenticate) the WebSocket connection
+  const authenticate = useCallback(async (credentials: LiveAuthOptions): Promise<boolean> => {
+    try {
+      const response = await sendMessageAndWait({
+        type: 'AUTH',
+        payload: credentials
+      } as any, 5000)
+
+      const success = (response as any).authenticated || false
+      setAuthenticated(success)
+      return success
+    } catch {
+      return false
+    }
+  }, [sendMessageAndWait])
+
   // Get WebSocket instance
   const getWebSocket = useCallback(() => {
     return wsRef.current
@@ -424,12 +493,14 @@ export function LiveComponentsProvider({
     connecting,
     error,
     connectionId,
+    authenticated,
     sendMessage,
     sendMessageAndWait,
     sendBinaryAndWait,
     registerComponent,
     unregisterComponent,
     reconnect,
+    authenticate,
     getWebSocket
   }
 

package/core/client/components/Live.tsx

@@ -52,16 +52,23 @@ type ExtractState<T> = T extends { new(...args: any[]): { state: infer S } }
   ? S extends Record<string, any> ? S : Record<string, any>
   : ExtractDefaultState<T>
 
-// Extrai as Actions (métodos públicos async) da classe do servidor
+// Extrai os nomes de publicActions como union type
+type ExtractPublicActionNames<T> = T extends { publicActions: readonly (infer A)[] }
+  ? A extends string ? A : never
+  : never
+
+// Extrai as Actions respeitando publicActions (MANDATORY)
+// - Se publicActions está definido: somente métodos listados são expostos
+// - Se publicActions NÃO está definido: nenhuma action disponível (secure by default)
 type ExtractActions<T> = T extends { new(...args: any[]): infer Instance }
-  ? {
-      [K in keyof Instance as Instance[K] extends (...args: any[]) => Promise<any>
-        ? K extends 'setState' | 'getState' | 'getValue' | 'setValue' | 'setValues' | 'getSnapshot'
-          ? never
-          : K
-        : never
-      ]: Instance[K]
-    }
+  ? T extends { publicActions: readonly string[] }
+    ? {
+        [K in keyof Instance as K extends ExtractPublicActionNames<T>
+          ? Instance[K] extends (...args: any[]) => Promise<any> ? K : never
+          : never
+        ]: Instance[K]
+      }
+    : Record<string, never>
   : Record<string, never>
 
 // ===== Opções do Live.use() =====
@@ -74,7 +81,7 @@ interface LiveUseOptions<TState> extends UseLiveComponentOptions {
 // ===== Hook Principal =====
 
 function useLive<
-  T extends { new(...args: any[]): any; defaultState?: Record<string, any>; componentName: string },
+  T extends { new(...args: any[]): any; defaultState?: Record<string, any>; componentName: string; publicActions?: readonly string[] },
   TBroadcasts extends Record<string, any> = Record<string, any>
 >(
   ComponentClass: T,