create-fluxstack 1.0.13 → 1.0.14

package/core/plugins/built-in/live-components/index.ts

@@ -0,0 +1,27 @@
+import type { FluxStack, PluginContext } from '../../types'
+import { createLiveComponentCommand } from './commands/create-live-component'
+
+type Plugin = FluxStack.Plugin
+
+// This is the entry point for the live-components built-in plugin.
+export const liveComponentsPlugin: Plugin = {
+  name: 'live-components',
+  version: '1.0.0',
+  description: 'Live Components CLI commands for FluxStack',
+  author: 'FluxStack Team',
+  priority: 500,
+  category: 'development',
+  tags: ['live-components', 'cli', 'generator'],
+  
+  setup: async (context: PluginContext) => {
+    context.logger.info('Live Components plugin initialized (CLI commands only)')
+  },
+  
+  // CLI commands
+  commands: [createLiveComponentCommand]
+}
+
+// Export commands for backward compatibility
+export const commands = [createLiveComponentCommand]
+
+export default liveComponentsPlugin

package/core/plugins/built-in/logger/index.ts

@@ -5,7 +5,7 @@ export const loggerPlugin: Plugin = {
   version: "1.0.0",
   description: "Enhanced logging plugin for FluxStack with request/response logging",
   author: "FluxStack Team",
-  priority: "highest", // Logger should run first
+  priority: 1000, // Logger should run first
   category: "core",
   tags: ["logging", "monitoring"],
   

package/core/plugins/built-in/monitoring/index.ts

@@ -66,7 +66,7 @@ export const monitoringPlugin: Plugin = {
   version: "1.0.0",
   description: "Performance monitoring plugin with metrics collection and system monitoring",
   author: "FluxStack Team",
-  priority: "high", // Should run early to capture all metrics
+  priority: 900, // Should run early to capture all metrics
   category: "monitoring",
   tags: ["monitoring", "metrics", "performance", "observability"],
   dependencies: [], // No dependencies

package/core/plugins/built-in/static/index.ts

@@ -7,7 +7,7 @@ export const staticPlugin: Plugin = {
   version: "1.0.0",
   description: "Enhanced static file serving plugin for FluxStack with caching and compression",
   author: "FluxStack Team",
-  priority: "low", // Should run after other plugins
+  priority: 100, // Should run after other plugins
   category: "core",
   tags: ["static", "files", "spa"],
   dependencies: [], // No hard dependencies, but works with vite plugin

package/core/plugins/built-in/swagger/index.ts

@@ -6,7 +6,7 @@ export const swaggerPlugin: Plugin = {
   version: '1.0.0',
   description: 'Enhanced Swagger documentation plugin for FluxStack with customizable options',
   author: 'FluxStack Team',
-  priority: 'normal',
+  priority: 500,
   category: 'documentation',
   tags: ['swagger', 'documentation', 'api'],
   dependencies: [], // No dependencies

package/core/plugins/built-in/vite/index.ts

@@ -8,7 +8,7 @@ export const vitePlugin: Plugin = {
   version: "1.0.0",
   description: "Enhanced Vite integration plugin for FluxStack with improved error handling and monitoring",
   author: "FluxStack Team",
-  priority: "high", // Should run early to setup proxying
+  priority: 800, // Should run early to setup proxying
   category: "development",
   tags: ["vite", "development", "hot-reload"],
   dependencies: [], // No dependencies

package/core/plugins/dependency-manager.ts

@@ -0,0 +1,384 @@
+/**
+ * Gerenciador de Dependências de Plugins
+ * Resolve e instala dependências de plugins automaticamente
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { join, resolve } from 'path'
+import { execSync } from 'child_process'
+import type { Logger } from '../utils/logger'
+
+export interface PluginDependency {
+  name: string
+  version: string
+  type: 'dependency' | 'devDependency' | 'peerDependency'
+  optional?: boolean
+}
+
+export interface DependencyResolution {
+  plugin: string
+  dependencies: PluginDependency[]
+  conflicts: DependencyConflict[]
+  resolved: boolean
+}
+
+export interface DependencyConflict {
+  package: string
+  versions: Array<{
+    plugin: string
+    version: string
+  }>
+  resolution?: string
+}
+
+export interface DependencyManagerConfig {
+  logger?: Logger
+  autoInstall?: boolean
+  packageManager?: 'npm' | 'yarn' | 'pnpm' | 'bun'
+  workspaceRoot?: string
+}
+
+export class PluginDependencyManager {
+  private logger?: Logger
+  private config: DependencyManagerConfig
+  private installedDependencies: Map<string, string> = new Map()
+  private pluginDependencies: Map<string, PluginDependency[]> = new Map()
+
+  constructor(config: DependencyManagerConfig = {}) {
+    this.config = {
+      autoInstall: true,
+      packageManager: 'bun',
+      workspaceRoot: process.cwd(),
+      ...config
+    }
+    this.logger = config.logger
+    
+    this.loadInstalledDependencies()
+  }
+
+  /**
+   * Registrar dependências de um plugin
+   */
+  registerPluginDependencies(pluginName: string, dependencies: PluginDependency[]): void {
+    this.pluginDependencies.set(pluginName, dependencies)
+    this.logger?.debug(`Dependências registradas para plugin '${pluginName}'`, {
+      plugin: pluginName,
+      dependencies: dependencies.length
+    })
+  }
+
+  /**
+   * Resolver dependências de um plugin a partir do package.json
+   */
+  async resolvePluginDependencies(pluginPath: string): Promise<DependencyResolution> {
+    const pluginName = this.getPluginNameFromPath(pluginPath)
+    const packageJsonPath = join(pluginPath, 'package.json')
+    
+    if (!existsSync(packageJsonPath)) {
+      return {
+        plugin: pluginName,
+        dependencies: [],
+        conflicts: [],
+        resolved: true
+      }
+    }
+
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+      const dependencies: PluginDependency[] = []
+
+      // Processar dependencies
+      if (packageJson.dependencies) {
+        for (const [name, version] of Object.entries(packageJson.dependencies)) {
+          dependencies.push({
+            name,
+            version: version as string,
+            type: 'dependency'
+          })
+        }
+      }
+
+      // Processar peerDependencies
+      if (packageJson.peerDependencies) {
+        for (const [name, version] of Object.entries(packageJson.peerDependencies)) {
+          const isOptional = packageJson.peerDependenciesMeta?.[name]?.optional || false
+          dependencies.push({
+            name,
+            version: version as string,
+            type: 'peerDependency',
+            optional: isOptional
+          })
+        }
+      }
+
+      // Registrar dependências
+      this.registerPluginDependencies(pluginName, dependencies)
+
+      // Detectar conflitos
+      const conflicts = this.detectConflicts(pluginName, dependencies)
+
+      return {
+        plugin: pluginName,
+        dependencies,
+        conflicts,
+        resolved: conflicts.length === 0
+      }
+    } catch (error) {
+      this.logger?.error(`Erro ao resolver dependências do plugin '${pluginName}'`, { error })
+      return {
+        plugin: pluginName,
+        dependencies: [],
+        conflicts: [],
+        resolved: false
+      }
+    }
+  }
+
+  /**
+   * Instalar dependências de plugins
+   */
+  async installPluginDependencies(resolutions: DependencyResolution[]): Promise<void> {
+    if (!this.config.autoInstall) {
+      this.logger?.info('Auto-instalação desabilitada, pulando instalação de dependências')
+      return
+    }
+
+    const toInstall: PluginDependency[] = []
+    const conflicts: DependencyConflict[] = []
+
+    // Coletar todas as dependências e conflitos
+    for (const resolution of resolutions) {
+      toInstall.push(...resolution.dependencies)
+      conflicts.push(...resolution.conflicts)
+    }
+
+    // Resolver conflitos primeiro
+    if (conflicts.length > 0) {
+      await this.resolveConflicts(conflicts)
+    }
+
+    // Filtrar dependências que já estão instaladas
+    const needsInstallation = toInstall.filter(dep => {
+      const installed = this.installedDependencies.get(dep.name)
+      return !installed || !this.isVersionCompatible(installed, dep.version)
+    })
+
+    if (needsInstallation.length === 0) {
+      this.logger?.info('Todas as dependências de plugins já estão instaladas')
+      return
+    }
+
+    this.logger?.info(`Instalando ${needsInstallation.length} dependências de plugins`, {
+      dependencies: needsInstallation.map(d => `${d.name}@${d.version}`)
+    })
+
+    try {
+      await this.installDependencies(needsInstallation)
+      this.logger?.info('Dependências de plugins instaladas com sucesso')
+    } catch (error) {
+      this.logger?.error('Erro ao instalar dependências de plugins', { error })
+      throw error
+    }
+  }
+
+  /**
+   * Detectar conflitos de versão
+   */
+  private detectConflicts(pluginName: string, dependencies: PluginDependency[]): DependencyConflict[] {
+    const conflicts: DependencyConflict[] = []
+
+    for (const dep of dependencies) {
+      const existingVersions: Array<{ plugin: string; version: string }> = []
+
+      // Verificar se outros plugins já declararam esta dependência
+      for (const [otherPlugin, otherDeps] of this.pluginDependencies.entries()) {
+        if (otherPlugin === pluginName) continue
+
+        const conflictingDep = otherDeps.find(d => d.name === dep.name)
+        if (conflictingDep && !this.isVersionCompatible(conflictingDep.version, dep.version)) {
+          existingVersions.push({
+            plugin: otherPlugin,
+            version: conflictingDep.version
+          })
+        }
+      }
+
+      if (existingVersions.length > 0) {
+        existingVersions.push({
+          plugin: pluginName,
+          version: dep.version
+        })
+
+        conflicts.push({
+          package: dep.name,
+          versions: existingVersions
+        })
+      }
+    }
+
+    return conflicts
+  }
+
+  /**
+   * Resolver conflitos de dependências
+   */
+  private async resolveConflicts(conflicts: DependencyConflict[]): Promise<void> {
+    this.logger?.warn(`Detectados ${conflicts.length} conflitos de dependências`, {
+      conflicts: conflicts.map(c => ({
+        package: c.package,
+        versions: c.versions.length
+      }))
+    })
+
+    for (const conflict of conflicts) {
+      // Estratégia simples: usar a versão mais alta
+      const sortedVersions = conflict.versions.sort((a, b) => {
+        return this.compareVersions(b.version, a.version)
+      })
+
+      const resolution = sortedVersions[0].version
+      conflict.resolution = resolution
+
+      this.logger?.info(`Conflito resolvido para '${conflict.package}': usando versão ${resolution}`, {
+        package: conflict.package,
+        resolution,
+        conflictingVersions: conflict.versions
+      })
+    }
+  }
+
+  /**
+   * Instalar dependências usando o package manager configurado
+   */
+  private async installDependencies(dependencies: PluginDependency[]): Promise<void> {
+    const regularDeps = dependencies.filter(d => d.type === 'dependency')
+    const peerDeps = dependencies.filter(d => d.type === 'peerDependency' && !d.optional)
+
+    if (regularDeps.length > 0) {
+      const packages = regularDeps.map(d => `${d.name}@${d.version}`).join(' ')
+      const command = this.getInstallCommand(packages, false)
+      
+      this.logger?.debug(`Executando: ${command}`)
+      execSync(command, { 
+        cwd: this.config.workspaceRoot,
+        stdio: 'inherit'
+      })
+    }
+
+    if (peerDeps.length > 0) {
+      const packages = peerDeps.map(d => `${d.name}@${d.version}`).join(' ')
+      const command = this.getInstallCommand(packages, false) // Peer deps como regulares
+      
+      this.logger?.debug(`Executando: ${command}`)
+      execSync(command, { 
+        cwd: this.config.workspaceRoot,
+        stdio: 'inherit'
+      })
+    }
+
+    // Recarregar dependências instaladas
+    this.loadInstalledDependencies()
+  }
+
+  /**
+   * Obter comando de instalação baseado no package manager
+   */
+  private getInstallCommand(packages: string, dev: boolean): string {
+    const devFlag = dev ? '--save-dev' : ''
+    
+    switch (this.config.packageManager) {
+      case 'npm':
+        return `npm install ${devFlag} ${packages}`
+      case 'yarn':
+        return `yarn add ${dev ? '--dev' : ''} ${packages}`
+      case 'pnpm':
+        return `pnpm add ${devFlag} ${packages}`
+      case 'bun':
+        return `bun add ${devFlag} ${packages}`
+      default:
+        return `npm install ${devFlag} ${packages}`
+    }
+  }
+
+  /**
+   * Carregar dependências já instaladas
+   */
+  private loadInstalledDependencies(): void {
+    const packageJsonPath = join(this.config.workspaceRoot!, 'package.json')
+    
+    if (!existsSync(packageJsonPath)) {
+      return
+    }
+
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+      
+      // Carregar dependencies
+      if (packageJson.dependencies) {
+        for (const [name, version] of Object.entries(packageJson.dependencies)) {
+          this.installedDependencies.set(name, version as string)
+        }
+      }
+
+      // Carregar devDependencies
+      if (packageJson.devDependencies) {
+        for (const [name, version] of Object.entries(packageJson.devDependencies)) {
+          this.installedDependencies.set(name, version as string)
+        }
+      }
+    } catch (error) {
+      this.logger?.warn('Erro ao carregar package.json principal', { error })
+    }
+  }
+
+  /**
+   * Verificar se versões são compatíveis
+   */
+  private isVersionCompatible(installed: string, required: string): boolean {
+    // Implementação simples - em produção usaria semver
+    if (required.startsWith('^') || required.startsWith('~')) {
+      const requiredVersion = required.slice(1)
+      return this.compareVersions(installed, requiredVersion) >= 0
+    }
+    
+    return installed === required
+  }
+
+  /**
+   * Comparar versões (implementação simples)
+   */
+  private compareVersions(a: string, b: string): number {
+    const aParts = a.replace(/[^\d.]/g, '').split('.').map(Number)
+    const bParts = b.replace(/[^\d.]/g, '').split('.').map(Number)
+    
+    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+      const aPart = aParts[i] || 0
+      const bPart = bParts[i] || 0
+      
+      if (aPart > bPart) return 1
+      if (aPart < bPart) return -1
+    }
+    
+    return 0
+  }
+
+  /**
+   * Extrair nome do plugin do caminho
+   */
+  private getPluginNameFromPath(pluginPath: string): string {
+    return pluginPath.split('/').pop() || 'unknown'
+  }
+
+  /**
+   * Obter estatísticas de dependências
+   */
+  getStats() {
+    return {
+      totalPlugins: this.pluginDependencies.size,
+      totalDependencies: Array.from(this.pluginDependencies.values())
+        .reduce((sum, deps) => sum + deps.length, 0),
+      installedDependencies: this.installedDependencies.size,
+      packageManager: this.config.packageManager
+    }
+  }
+}

package/core/plugins/index.ts

@@ -5,7 +5,7 @@
 
 // Core plugin types and interfaces
 export type {
-    Plugin,
+    FluxStack,
     PluginContext,
     PluginHook,
     PluginPriority,
@@ -27,6 +27,8 @@ export type {
     BuildContext
 } from './types'
 
+export type Plugin = FluxStack.Plugin
+
 // Plugin registry
 export { PluginRegistry } from './registry'
 export type { PluginRegistryConfig } from './registry'
@@ -78,6 +80,7 @@ export const PluginUtils = {
         onServerStart?: (context: PluginContext) => void | Promise<void>
         onServerStop?: (context: PluginContext) => void | Promise<void>
         onRequest?: (context: RequestContext) => void | Promise<void>
+        onBeforeRoute?: (context: RequestContext) => void | Promise<void>
         onResponse?: (context: ResponseContext) => void | Promise<void>
         onError?: (context: ErrorContext) => void | Promise<void>
         configSchema?: any
@@ -93,6 +96,7 @@ export const PluginUtils = {
             ...(config.onServerStart && { onServerStart: config.onServerStart }),
             ...(config.onServerStop && { onServerStop: config.onServerStop }),
             ...(config.onRequest && { onRequest: config.onRequest }),
+            ...(config.onBeforeRoute && { onBeforeRoute: config.onBeforeRoute }),
             ...(config.onResponse && { onResponse: config.onResponse }),
             ...(config.onError && { onError: config.onError }),
             ...(config.configSchema && { configSchema: config.configSchema }),

package/core/plugins/manager.ts

@@ -4,7 +4,7 @@
  */
 
 import type { 
-  Plugin, 
+  FluxStack,
   PluginContext, 
   PluginHook, 
   PluginHookResult, 
@@ -16,6 +16,8 @@ import type {
   ErrorContext,
   BuildContext
 } from "./types"
+
+type Plugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
 import type { Logger } from "../utils/logger/index"
 import { PluginRegistry } from "./registry"
@@ -394,8 +396,10 @@ export class PluginManager extends EventEmitter {
    */
   private async discoverPlugins(): Promise<void> {
     try {
+      this.logger.info('Discovering external plugins in directory: plugins')
       const results = await this.registry.discoverPlugins({
-        includeBuiltIn: true,
+        directories: ['plugins'],
+        includeBuiltIn: false,
         includeExternal: true
       })
 
@@ -444,7 +448,7 @@ export class PluginManager extends EventEmitter {
 
     const context: PluginContext = {
       config: this.config,
-      logger: this.logger.child({ plugin: plugin.name }),
+      logger: this.logger,
       app: this.app,
       utils: createPluginUtils(this.logger),
       registry: this.registry