create-fluxstack 1.0.13 → 1.0.15

package/core/plugins/registry.ts

@@ -1,7 +1,10 @@
-import type { Plugin, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
+import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
+
+type FluxStackPlugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
 import type { Logger } from "../utils/logger/index"
 import { FluxStackError } from "../utils/errors"
+import { PluginDependencyManager } from "./dependency-manager"
 import { readdir, readFile } from "fs/promises"
 import { join, resolve } from "path"
 import { existsSync } from "fs"
@@ -13,23 +16,29 @@ export interface PluginRegistryConfig {
 }
 
 export class PluginRegistry {
-  private plugins: Map<string, Plugin> = new Map()
+  private plugins: Map<string, FluxStackPlugin> = new Map()
   private manifests: Map<string, PluginManifest> = new Map()
   private loadOrder: string[] = []
   private dependencies: Map<string, string[]> = new Map()
   private conflicts: string[] = []
   private logger?: Logger
   private config?: FluxStackConfig
+  private dependencyManager: PluginDependencyManager
 
   constructor(options: PluginRegistryConfig = {}) {
     this.logger = options.logger
     this.config = options.config
+    this.dependencyManager = new PluginDependencyManager({
+      logger: this.logger,
+      autoInstall: true,
+      packageManager: 'bun'
+    })
   }
 
   /**
    * Register a plugin with the registry
    */
-  async register(plugin: Plugin, manifest?: PluginManifest): Promise<void> {
+  async register(plugin: FluxStackPlugin, manifest?: PluginManifest): Promise<void> {
     if (this.plugins.has(plugin.name)) {
       throw new FluxStackError(
         `Plugin '${plugin.name}' is already registered`,
@@ -100,7 +109,7 @@ export class PluginRegistry {
   /**
    * Get a plugin by name
    */
-  get(name: string): Plugin | undefined {
+  get(name: string): FluxStackPlugin | undefined {
     return this.plugins.get(name)
   }
 
@@ -114,7 +123,7 @@ export class PluginRegistry {
   /**
    * Get all registered plugins
    */
-  getAll(): Plugin[] {
+  getAll(): FluxStackPlugin[] {
     return Array.from(this.plugins.values())
   }
 
@@ -208,19 +217,23 @@ export class PluginRegistry {
   async discoverPlugins(options: PluginDiscoveryOptions = {}): Promise<PluginLoadResult[]> {
     const results: PluginLoadResult[] = []
     const {
-      directories = ['core/plugins/built-in', 'plugins', 'node_modules'],
+      directories = ['plugins'],
       patterns: _patterns = ['**/plugin.{js,ts}', '**/index.{js,ts}'],
-      includeBuiltIn: _includeBuiltIn = true,
+      includeBuiltIn: _includeBuiltIn = false,
       includeExternal: _includeExternal = true
     } = options
 
+    // Descobrir plugins
     for (const directory of directories) {
+      this.logger?.info(`Scanning directory: ${directory}`)
       if (!existsSync(directory)) {
+        this.logger?.warn(`Directory does not exist: ${directory}`)
         continue
       }
 
       try {
         const pluginResults = await this.discoverPluginsInDirectory(directory, _patterns)
+        this.logger?.info(`Found ${pluginResults.length} plugins in ${directory}`)
         results.push(...pluginResults)
       } catch (error) {
         this.logger?.warn(`Failed to discover plugins in directory '${directory}'`, { error })
@@ -231,6 +244,9 @@ export class PluginRegistry {
       }
     }
 
+    // Resolver e instalar dependências
+    await this.resolveDependencies(results)
+
     return results
   }
 
@@ -250,7 +266,7 @@ export class PluginRegistry {
 
       // Try to import the plugin
       const pluginModule = await import(resolve(pluginPath))
-      const plugin: Plugin = pluginModule.default || pluginModule
+      const plugin: FluxStackPlugin = pluginModule.default || pluginModule
 
       if (!plugin || typeof plugin !== 'object' || !plugin.name) {
         return {
@@ -278,7 +294,7 @@ export class PluginRegistry {
   /**
    * Validate plugin structure
    */
-  private validatePlugin(plugin: Plugin): void {
+  private validatePlugin(plugin: FluxStackPlugin): void {
     if (!plugin.name || typeof plugin.name !== 'string') {
       throw new FluxStackError(
         'Plugin must have a valid name property',
@@ -315,7 +331,7 @@ export class PluginRegistry {
   /**
    * Validate plugin configuration against schema
    */
-  private validatePluginConfig(plugin: Plugin, config: any): void {
+  private validatePluginConfig(plugin: FluxStackPlugin, config: any): void {
     if (!plugin.configSchema) {
       return
     }
@@ -387,6 +403,62 @@ 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
+    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`, {
+                conflicts: resolution.conflicts.length
+              })
+            }
+          }
+        } catch (error) {
+          this.logger?.warn(`Erro ao resolver dependências do 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 })
+      }
+    }
+  }
+
+  /**
+   * Encontrar diretório de um plugin pelo nome
+   */
+  private findPluginDirectory(pluginName: string): string | null {
+    const possiblePaths = [
+      `plugins/${pluginName}`,
+      `core/plugins/built-in/${pluginName}`
+    ]
+
+    for (const path of possiblePaths) {
+      if (existsSync(path)) {
+        return path
+      }
+    }
+
+    return null
+  }
+
   /**
    * Discover plugins in a specific directory
    */
@@ -404,12 +476,18 @@ export class PluginRegistry {
           const pluginDir = join(directory, entry.name)
           
           // Check if this looks like a plugin directory
+          // Skip if it's just an index file in the root of built-in directory
+          if (directory === 'core/plugins/built-in' && entry.name === 'index.ts') {
+            continue
+          }
+          
           const hasPluginFile = existsSync(join(pluginDir, 'index.ts')) || 
                                existsSync(join(pluginDir, 'index.js')) ||
                                existsSync(join(pluginDir, 'plugin.ts')) ||
                                existsSync(join(pluginDir, 'plugin.js'))
           
           if (hasPluginFile) {
+            this.logger?.info(`Loading plugin from: ${pluginDir}`)
             const result = await this.loadPlugin(pluginDir)
             results.push(result)
           }

package/core/plugins/types.ts

@@ -75,13 +75,16 @@ export interface PluginConfigSchema {
   additionalProperties?: boolean
 }
 
-export interface Plugin {
+export namespace FluxStack {
+  export interface Plugin {
   name: string
   version?: string
   description?: string
   author?: string
   dependencies?: string[]
   priority?: number | PluginPriority
+  category?: string
+  tags?: string[]
   
   // Lifecycle hooks
   setup?: (context: PluginContext) => void | Promise<void>
@@ -94,19 +97,16 @@ export interface Plugin {
   onBuild?: (context: BuildContext) => void | Promise<void>
   onBuildComplete?: (context: BuildContext) => void | Promise<void>
   
-  // CLI commands
-  commands?: CliCommand[]
-  
   // Configuration
   configSchema?: PluginConfigSchema
   defaultConfig?: any
   
-  // Plugin metadata
-  enabled?: boolean
-  tags?: string[]
-  category?: string
+  // CLI commands
+  commands?: CliCommand[]
+  }
 }
 
+
 export interface PluginManifest {
   name: string
   version: string
@@ -129,13 +129,13 @@ export interface PluginManifest {
 
 export interface PluginLoadResult {
   success: boolean
-  plugin?: Plugin
+  plugin?: FluxStack.Plugin
   error?: string
   warnings?: string[]
 }
 
 export interface PluginRegistryState {
-  plugins: Map<string, Plugin>
+  plugins: Map<string, FluxStack.Plugin>
   manifests: Map<string, PluginManifest>
   loadOrder: string[]
   dependencies: Map<string, string[]>
@@ -177,7 +177,7 @@ export interface PluginInstallOptions {
 }
 
 export interface PluginExecutionContext {
-  plugin: Plugin
+  plugin: FluxStack.Plugin
   hook: PluginHook
   startTime: number
   timeout?: number

package/core/server/framework.ts

@@ -1,6 +1,7 @@
 import { Elysia } from "elysia"
 import type { FluxStackConfig, FluxStackContext, Plugin } from "../types"
 import type { PluginContext, PluginUtils } from "../plugins/types"
+import { PluginManager } from "../plugins/manager"
 import { getConfigSync, getEnvironmentInfo } from "../config"
 import { logger, type Logger } from "../utils/logger/index"
 import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
@@ -10,8 +11,10 @@ export class FluxStackFramework {
   private context: FluxStackContext
   private pluginContext: PluginContext
   private plugins: Plugin[] = []
+  private pluginManager: PluginManager
 
   constructor(config?: Partial<FluxStackConfig>) {
+    console.log('🚀 [DEBUG] FluxStackFramework constructor called!')
     // Load the full configuration
     const fullConfig = config ? { ...getConfigSync(), ...config } : getConfigSync()
     const envInfo = getEnvironmentInfo()
@@ -67,7 +70,41 @@ export class FluxStackFramework {
       utils: pluginUtils
     }
 
+    // Initialize plugin manager
+    this.pluginManager = new PluginManager({
+      config: fullConfig,
+      logger: logger as Logger,
+      app: this.app
+    })
+
     this.setupCors()
+    
+    console.log('🔍 [DEBUG] About to call initializePluginsAsync()...')
+    // Initialize plugins automatically in the background
+    this.initializePluginsAsync().catch(error => {
+      console.error('❌ [DEBUG] Failed to initialize plugins async:', error)
+    })
+    console.log('🔍 [DEBUG] initializePluginsAsync() call dispatched')
+  }
+
+  private async initializePluginsAsync() {
+    console.log('🚀 [DEBUG] initializePluginsAsync() CALLED!')
+    try {
+      console.log('🔍 [DEBUG] Starting automatic plugin discovery...')
+      console.log('🔍 [DEBUG] Current working directory:', process.cwd())
+      logger.info('[FluxStack] Initializing automatic plugin discovery...')
+      await this.pluginManager.initialize()
+      const stats = this.pluginManager.getRegistry().getStats()
+      console.log('🔍 [DEBUG] Plugin discovery completed:', stats)
+      logger.info('[FluxStack] Automatic plugins loaded successfully', {
+        pluginCount: stats.totalPlugins,
+        enabledPlugins: stats.enabledPlugins,
+        disabledPlugins: stats.disabledPlugins
+      })
+    } catch (error) {
+      console.error('❌ [DEBUG] Plugin discovery error:', error)
+      logger.error('[FluxStack] Failed to initialize automatic plugins', { error })
+    }
   }
 
   private setupCors() {
@@ -114,6 +151,12 @@ export class FluxStackFramework {
     const apiPrefix = this.context.config.server.apiPrefix
 
     this.app.listen(port, () => {
+      logger.info('[FluxStack] Server started on port ' + port, {
+        apiPrefix,
+        environment: this.context.environment,
+        manualPlugins: this.plugins.length,
+        automaticPlugins: this.pluginManager.getRegistry().getStats().totalPlugins
+      })
       console.log(`🚀 API ready at http://localhost:${port}${apiPrefix}`)
       console.log(`📋 Health check: http://localhost:${port}${apiPrefix}/health`)
       console.log()

package/core/server/index.ts

@@ -5,4 +5,14 @@ export { vitePlugin } from "../plugins/built-in/vite"
 export { staticPlugin } from "../plugins/built-in/static"
 export { swaggerPlugin } from "../plugins/built-in/swagger"
 export { PluginRegistry } from "../plugins/registry"
-export * from "../types"
+export * from "../types"
+
+// Live Components exports
+export { liveComponentsPlugin } from "./live/websocket-plugin"
+export { componentRegistry } from "./live/ComponentRegistry"
+export { LiveComponent } from "../types/types"
+
+// Static Files Plugin
+export { staticFilesPlugin } from "./plugins/static-files-plugin"
+
+export * from "../types/types"