create-fluxstack 1.7.5 → 1.8.3

package/core/plugins/config.ts

@@ -4,8 +4,8 @@
  */
 
 import type { FluxStack, PluginConfigSchema, PluginValidationResult } from "./types"
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger/index"
 
 type Plugin = FluxStack.Plugin
 

package/core/plugins/dependency-manager.ts

@@ -6,7 +6,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs'
 import { join, resolve } from 'path'
 import { execSync } from 'child_process'
-import type { Logger } from '../utils/logger'
+import type { Logger } from '@/core/utils/logger'
 
 export interface PluginDependency {
   name: string
@@ -176,7 +176,7 @@ export class PluginDependencyManager {
   /**
    * Instalar dependências no diretório local do plugin
    */
-  private async installPluginDependenciesLocally(pluginPath: string, dependencies: PluginDependency[]): Promise<void> {
+  async installPluginDependenciesLocally(pluginPath: string, dependencies: PluginDependency[]): Promise<void> {
     if (dependencies.length === 0) return
 
     const regularDeps = dependencies.filter(d => d.type === 'dependency')

package/core/plugins/discovery.ts

@@ -4,7 +4,7 @@
  */
 
 import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
-import type { Logger } from "../utils/logger/index"
+import type { Logger } from "@/core/utils/logger/index"
 import { readdir, readFile } from "fs/promises"
 import { join, resolve } from "path"
 import { existsSync } from "fs"

package/core/plugins/executor.ts

@@ -10,8 +10,8 @@ import type {
   PluginPriority,
   HookExecutionOptions
 } from "./types"
-import type { Logger } from "../utils/logger/index"
-import { FluxStackError } from "../utils/errors"
+import type { Logger } from "@/core/utils/logger/index"
+import { FluxStackError } from "@/core/utils/errors"
 
 export interface PluginExecutionPlan {
   hook: PluginHook

package/core/plugins/manager.ts

@@ -18,13 +18,28 @@ import type {
 } from "./types"
 
 type Plugin = FluxStack.Plugin
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger"
 import { PluginRegistry } from "./registry"
 import { createPluginUtils } from "./config"
-import { FluxStackError } from "../utils/errors"
+import { FluxStackError } from "@/core/utils/errors"
 import { EventEmitter } from "events"
 
+/**
+ * Helper to safely parse request.url which might be relative or absolute
+ */
+function parseRequestURL(request: Request): URL {
+  try {
+    // Try parsing as absolute URL first
+    return new URL(request.url)
+  } catch {
+    // If relative, use host from headers or default to localhost
+    const host = request.headers.get('host') || 'localhost'
+    const protocol = request.headers.get('x-forwarded-proto') || 'http'
+    return new URL(request.url, `${protocol}://${host}`)
+  }
+}
+
 export interface PluginManagerConfig {
   config: FluxStackConfig
   logger: Logger
@@ -558,7 +573,7 @@ export class PluginManager extends EventEmitter {
  * Create request context from HTTP request
  */
 export function createRequestContext(request: Request, additionalData: any = {}): RequestContext {
-  const url = new URL(request.url)
+  const url = parseRequestURL(request)
   
   return {
     request,

package/core/plugins/module-resolver.ts

@@ -5,7 +5,7 @@
 
 import { existsSync } from 'fs'
 import { join, resolve } from 'path'
-import type { Logger } from '../utils/logger'
+import type { Logger } from '@/core/utils/logger'
 
 export interface ModuleResolverConfig {
   projectRoot: string

package/core/plugins/registry.ts

@@ -1,9 +1,9 @@
 import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
 
 type FluxStackPlugin = FluxStack.Plugin
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger"
-import { FluxStackError } from "../utils/errors"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger"
+import { FluxStackError } from "@/core/utils/errors"
 import { PluginDependencyManager } from "./dependency-manager"
 import { readdir, readFile } from "fs/promises"
 import { join, resolve } from "path"
@@ -291,7 +291,21 @@ export class PluginRegistry {
         }
       }
 
-      // Try to import the plugin
+      // Install dependencies BEFORE importing the plugin
+      if (manifest && manifest.dependencies && Object.keys(manifest.dependencies).length > 0) {
+        try {
+          const resolution = await this.dependencyManager.resolvePluginDependencies(pluginPath)
+          if (resolution.dependencies.length > 0) {
+            // Install dependencies directly in the plugin directory
+            await this.dependencyManager.installPluginDependenciesLocally(pluginPath, resolution.dependencies)
+            this.logger?.debug(`Dependencies installed for plugin at: ${pluginPath}`)
+          }
+        } catch (error) {
+          this.logger?.warn(`Failed to install dependencies for plugin at '${pluginPath}'`, { error })
+        }
+      }
+
+      // Try to import the plugin (after dependencies are installed)
       const pluginModule = await import(resolve(pluginPath))
       const plugin: FluxStackPlugin = pluginModule.default || pluginModule
 
@@ -434,38 +448,28 @@ export class PluginRegistry {
    * Resolver dependências de todos os plugins descobertos
    */
   private async resolveDependencies(results: PluginLoadResult[]): Promise<void> {
-    const resolutions = []
-    
-    // Resolver dependências para cada plugin carregado com sucesso
+    // Dependencies are now installed during plugin loading in loadPlugin()
+    // This method is kept for compatibility but no longer performs installation
+
+    // Only check for dependency conflicts on successfully loaded plugins
     for (const result of results) {
       if (result.success && result.plugin) {
         try {
-          // Tentar encontrar o diretório do plugin
           const pluginDir = this.findPluginDirectory(result.plugin.name)
           if (pluginDir) {
             const resolution = await this.dependencyManager.resolvePluginDependencies(pluginDir)
-            resolutions.push(resolution)
-            
+
             if (!resolution.resolved) {
-              this.logger?.warn(`Plugin '${result.plugin.name}' tem conflitos de dependências`, {
+              this.logger?.warn(`Plugin '${result.plugin.name}' has dependency conflicts`, {
                 conflicts: resolution.conflicts.length
               })
             }
           }
         } catch (error) {
-          this.logger?.warn(`Erro ao resolver dependências do plugin '${result.plugin.name}'`, { error })
+          this.logger?.warn(`Failed to check dependencies for plugin '${result.plugin.name}'`, { error })
         }
       }
     }
-
-    // Instalar dependências se houver resoluções
-    if (resolutions.length > 0) {
-      try {
-        await this.dependencyManager.installPluginDependencies(resolutions)
-      } catch (error) {
-        this.logger?.error('Erro ao instalar dependências de plugins', { error })
-      }
-    }
   }
 
   /**

package/core/plugins/types.ts

@@ -1,5 +1,5 @@
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger/index"
 
 export type PluginHook = 
   | 'setup'
@@ -96,11 +96,31 @@ export namespace FluxStack {
   onError?: (context: ErrorContext) => void | Promise<void>
   onBuild?: (context: BuildContext) => void | Promise<void>
   onBuildComplete?: (context: BuildContext) => void | Promise<void>
-  
+
   // Configuration
+  /**
+   * @deprecated Use declarative config system instead (plugins/[name]/config/)
+   * Create a config/ folder with defineConfig() for type-safe configuration.
+   * This property is kept for backward compatibility with built-in plugins.
+   *
+   * @example
+   * // ✅ New way (recommended):
+   * // plugins/my-plugin/config/index.ts
+   * import { defineConfig, config } from '@/core/utils/config-schema'
+   * export const myConfig = defineConfig({ ... })
+   *
+   * // ❌ Old way (deprecated):
+   * configSchema: { type: 'object', properties: { ... } }
+   */
   configSchema?: PluginConfigSchema
+
+  /**
+   * @deprecated Use declarative config system with defineConfig()
+   * This property will be removed in a future major version.
+   * Use the config/ folder structure for automatic type inference.
+   */
   defaultConfig?: any
-  
+
   // CLI commands
   commands?: CliCommand[]
   }
@@ -251,4 +271,126 @@ export interface CliContext {
     name: string
     version: string
   }
-}
+}
+
+// Live Components Types
+export interface LiveComponent<TState = any> {
+  id: string
+  name: string
+  state: TState
+  mounted: boolean
+  socket?: any
+  userId?: string
+  destroy?: () => void
+  executeAction?: (action: string, payload?: any) => Promise<any>
+  setState?: (newState: Partial<TState>) => void
+  getSerializableState?: () => TState
+}
+
+export interface LiveMessage {
+  type: string
+  componentId: string
+  data?: any
+  payload?: any
+  action?: string
+  property?: string
+  userId?: string
+  expectResponse?: boolean
+  timestamp?: number
+  requestId?: string
+  room?: string
+}
+
+export interface BroadcastMessage {
+  type: string
+  data?: any
+  channel?: string
+  room?: string
+  payload?: any
+  excludeUser?: string
+}
+
+export interface ComponentDefinition<TState = any> {
+  name: string
+  initialState: TState
+  handlers?: Record<string, Function>
+  component?: any
+}
+
+export interface WebSocketData {
+  componentId?: string
+  userId?: string
+  sessionId?: string
+}
+
+// File Upload Types
+export interface ActiveUpload {
+  uploadId: string
+  componentId?: string
+  filename: string
+  fileType?: string
+  fileSize?: number
+  totalChunks: number
+  receivedChunks: Map<number, any>
+  startTime: number
+  lastChunkTime?: number
+}
+
+export interface FileUploadStartMessage {
+  type: 'upload:start' | 'FILE_UPLOAD_START'
+  uploadId: string
+  filename: string
+  totalChunks: number
+  fileSize: number
+  componentId?: string
+  fileType?: string
+  chunkSize?: number
+  requestId?: string
+}
+
+export interface FileUploadChunkMessage {
+  type: 'upload:chunk' | 'FILE_UPLOAD_CHUNK'
+  uploadId: string
+  chunkIndex: number
+  data: string | ArrayBuffer
+  totalChunks?: number
+  componentId?: string
+  requestId?: string
+}
+
+export interface FileUploadCompleteMessage {
+  type: 'upload:complete' | 'FILE_UPLOAD_COMPLETE'
+  uploadId: string
+  requestId?: string
+}
+
+export interface FileUploadProgressResponse {
+  type: 'upload:progress' | 'FILE_UPLOAD_PROGRESS'
+  uploadId: string
+  receivedChunks?: number
+  totalChunks?: number
+  percentage?: number
+  componentId?: string
+  chunkIndex?: number
+  bytesUploaded?: number
+  totalBytes?: number
+  progress?: number
+  timestamp?: number
+}
+
+export interface FileUploadCompleteResponse {
+  type: 'upload:complete' | 'FILE_UPLOAD_COMPLETE'
+  uploadId: string
+  url?: string
+  filename?: string
+  size?: number
+  componentId?: string
+  success?: boolean
+  error?: string
+  message?: string
+  fileUrl?: string
+  timestamp?: number
+}
+
+// Plugin Type Export
+export type Plugin = FluxStack.Plugin

package/core/server/backend-entry.ts

@@ -0,0 +1,51 @@
+/**
+ * Backend Entry Point - Core Framework
+ *
+ * This file contains the protected logic for running backend standalone mode.
+ * DO NOT modify this file directly - it's part of the FluxStack framework core.
+ *
+ * For customization, use app/server/backend-only.ts
+ */
+
+import type { Elysia } from "elysia"
+import { startBackendOnly } from "./standalone"
+
+export interface BackendEntryConfig {
+  port: number
+  apiPrefix?: string
+  host?: string
+}
+
+/**
+ * Start backend in standalone mode
+ *
+ * @param apiRoutes - Elysia routes from app/server/routes
+ * @param config - Backend configuration
+ */
+export function startBackend(
+  apiRoutes: Elysia,
+  config: BackendEntryConfig
+) {
+  const { port, apiPrefix = '/api', host = 'localhost' } = config
+
+  console.log(`🚀 Backend standalone: ${host}:${port}`)
+  console.log(`📡 API Prefix: ${apiPrefix}`)
+  console.log()
+
+  // Start backend using the standalone utility
+  startBackendOnly(apiRoutes, { port, apiPrefix })
+}
+
+/**
+ * Create backend entry config from declarative config
+ * Helper to make it easy to use with the config system
+ */
+export function createBackendConfig(
+  serverConfig: { server: { backendPort: number; apiPrefix: string; host: string } }
+): BackendEntryConfig {
+  return {
+    port: serverConfig.server.backendPort,
+    apiPrefix: serverConfig.server.apiPrefix,
+    host: serverConfig.server.host
+  }
+}

package/core/server/framework.ts

@@ -65,7 +65,7 @@ export class FluxStackFramework {
     // Create plugin context
     this.pluginContext = {
       config: fullConfig,
-      logger: logger as Logger,
+      logger: logger as any,
       app: this.app,
       utils: pluginUtils
     }
@@ -73,7 +73,7 @@ export class FluxStackFramework {
     // Initialize plugin manager
     this.pluginManager = new PluginManager({
       config: fullConfig,
-      logger: logger as Logger,
+      logger: logger as any,
       app: this.app
     })
 

package/core/server/live/ComponentRegistry.ts

@@ -6,7 +6,7 @@ import type {
   BroadcastMessage, 
   ComponentDefinition,
   WebSocketData 
-} from '../../types/types'
+} from '@/core/plugins/types'
 import { stateSignature, type SignedState } from './StateSignature'
 import { performanceMonitor } from './LiveComponentPerformanceMonitor'
 
@@ -151,7 +151,7 @@ export class ComponentRegistry {
     try {
       const fs = await import('fs')
       const path = await import('path')
-      const { startGroup, endGroup, logInGroup, groupSummary } = await import('../../utils/logger/group-logger')
+      const { startGroup, endGroup, logInGroup, groupSummary } = await import('@/core/utils/logger/group-logger')
 
       if (!fs.existsSync(componentsPath)) {
         console.log(`⚠️ Components path not found: ${componentsPath}`)
@@ -159,15 +159,9 @@ export class ComponentRegistry {
       }
 
       const files = fs.readdirSync(componentsPath)
-      let discoveredCount = 0
-
-      startGroup({
-        title: 'Live Components Auto-Discovery',
-        icon: '🔍',
-        color: 'blue',
-        collapsed: true
-      })
+      const components: string[] = []
 
+      // Discovery with component names collection
       for (const file of files) {
         if (file.endsWith('.ts') || file.endsWith('.js')) {
           try {
@@ -183,30 +177,19 @@ export class ComponentRegistry {
 
                 const componentName = exportName.replace(/Component$/, '')
                 this.registerComponentClass(componentName, exportedItem)
-                logInGroup(`${componentName} (from ${file})`, '📦')
-                discoveredCount++
+                components.push(componentName)
               }
             })
-
-            // Check for integration hooks (like SystemMonitorIntegration)
-            if (module.default && typeof module.default === 'object' && module.default.setupIntegration) {
-              logInGroup('Integration hooks found', '🔗')
-            }
           } catch (error) {
-            logInGroup(`Failed to load ${file}`, '⚠️')
+            // Silent - only log in debug mode
           }
         }
       }
 
-      if (discoveredCount > 0) {
-        const label = discoveredCount === 1 ? 'component discovered' : 'components discovered'
-        groupSummary(discoveredCount, label, '✓')
-      } else {
-        logInGroup('No components found', '⚠️')
+      // Display components in a compact single line format
+      if (components.length > 0) {
+        console.log(`\nLive Components (${components.length}): ${components.join(', ')}\n`)
       }
-
-      endGroup()
-      console.log('') // Separator line
     } catch (error) {
       console.error('❌ Auto-discovery failed:', error)
     }

package/core/server/live/FileUploadManager.ts

@@ -8,7 +8,7 @@ import type {
   FileUploadCompleteMessage,
   FileUploadProgressResponse,
   FileUploadCompleteResponse
-} from '../../types/types'
+} from '@/core/plugins/types'
 
 export class FileUploadManager {
   private activeUploads = new Map<string, ActiveUpload>()

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

@@ -0,0 +1,26 @@
+// 🔥 Auto-generated Live Components Registration
+// This file is automatically generated during build time - DO NOT EDIT MANUALLY
+// Generated at: 2025-11-12T22:57:08.521Z
+
+import { LiveClockComponent } from "@/app/server/live/LiveClockComponent"
+import { componentRegistry } from "@/core/server/live/ComponentRegistry"
+
+// Register all components statically for production bundle
+function registerAllComponents() {
+  try {
+    // Auto-generated component registrations
+    componentRegistry.registerComponentClass('LiveClock', LiveClockComponent)
+    
+    console.log('📝 Live components registered successfully! (1 components)')
+  } catch (error) {
+    console.warn('⚠️ Error registering components:', error)
+  }
+}
+
+// Auto-register components
+registerAllComponents()
+
+// Export all components to ensure they're included in the bundle
+export { 
+  LiveClockComponent
+}