create-fluxstack 1.10.1 → 1.12.0

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

@@ -1,231 +1,131 @@
-import type { FluxStack, PluginContext, RequestContext } from "@/core/plugins/types"
-import { FLUXSTACK_VERSION } from "@/core/utils/version"
-import { clientConfig } from '@/config/client.config'
-import { isDevelopment } from "@/core/utils/helpers"
+import type { FluxStack, PluginContext, RequestContext } from "@core/plugins/types"
+import { FLUXSTACK_VERSION } from "@core/utils/version"
+import { clientConfig } from '@config'
+import { pluginsConfig } from '@config'
+import { isDevelopment } from "@core/utils/helpers"
 import { join } from "path"
 import { statSync, existsSync } from "fs"
 
 type Plugin = FluxStack.Plugin
 
-// Default configuration values (uses clientConfig from /config)
-const DEFAULTS = {
-  enabled: true,
-  port: clientConfig.vite.port,
-  host: clientConfig.vite.host,
-  checkInterval: 2000,
-  maxRetries: 10,
-  timeout: 5000,
-  proxyPaths: [] as string[],
-  excludePaths: [] as string[],
-  // Static file serving (production) - uses clientConfig
-  publicDir: clientConfig.build.outDir,
-  indexFile: "index.html"
+const PLUGIN_PRIORITY = 800
+const INDEX_FILE = "index.html"
+
+/** Create static file handler with cached base directory */
+function createStaticFallback() {
+  // Discover base directory once
+  const baseDir = existsSync('client') ? 'client'
+    : existsSync('dist/client') ? 'dist/client'
+    : clientConfig.build.outDir ?? 'dist/client'
+
+  return (c: { request?: Request }) => {
+    const req = c.request
+    if (!req) return
+
+    let pathname = decodeURIComponent(new URL(req.url).pathname)
+    if (pathname === '/' || pathname === '') {
+      pathname = `/${INDEX_FILE}`
+    }
+
+    // Try to serve the requested file
+    const filePath = join(baseDir, pathname)
+    try {
+      if (statSync(filePath).isFile()) {
+        return Bun.file(filePath)
+      }
+    } catch {}
+
+    // SPA fallback: serve index.html
+    const indexPath = join(baseDir, INDEX_FILE)
+    try {
+      statSync(indexPath)
+      return Bun.file(indexPath)
+    } catch {}
+  }
 }
 
-/**
- * Helper to safely parse request.url which might be relative or absolute
- */
-function parseRequestURL(request: Request): URL {
+/** Proxy request to Vite dev server */
+async function proxyToVite(ctx: RequestContext): Promise<void> {
+  const { host, port } = clientConfig.vite
+
   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}`)
+    // Parse URL (handle relative URLs)
+    let url: URL
+    try {
+      url = new URL(ctx.request.url)
+    } catch {
+      const reqHost = ctx.request.headers.get('host') || 'localhost'
+      const protocol = ctx.request.headers.get('x-forwarded-proto') || 'http'
+      url = new URL(ctx.request.url, `${protocol}://${reqHost}`)
+    }
+
+    const response = await fetch(`http://${host}:${port}${ctx.path}${url.search}`, {
+      method: ctx.method,
+      headers: ctx.headers,
+      body: ctx.method !== 'GET' && ctx.method !== 'HEAD' ? ctx.request.body : undefined
+    })
+
+    ctx.handled = true
+    ctx.response = new Response(await response.arrayBuffer(), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    })
+  } catch (error) {
+    if (clientConfig.vite.enableLogging) {
+      console.warn(`Vite proxy error: ${error}`)
+    }
   }
 }
 
 export const vitePlugin: Plugin = {
   name: "vite",
   version: FLUXSTACK_VERSION,
-  description: "Enhanced Vite integration plugin for FluxStack with improved error handling and monitoring",
+  description: "Vite integration plugin for FluxStack",
   author: "FluxStack Team",
-  priority: 800, // Should run early to setup proxying
+  priority: PLUGIN_PRIORITY,
   category: "development",
   tags: ["vite", "development", "hot-reload"],
   dependencies: [],
 
   setup: async (context: PluginContext) => {
-    if (!DEFAULTS.enabled) {
-      context.logger.debug('Vite plugin disabled or no client configuration found')
+    if (!pluginsConfig.viteEnabled) {
+      context.logger.debug('Vite plugin disabled')
       return
     }
 
-    // Production mode: setup static file serving
     if (!isDevelopment()) {
-      context.logger.debug("Production mode: static file serving enabled", {
-        publicDir: DEFAULTS.publicDir
-      })
-
-      // Static fallback handler (runs last)
-      const staticFallback = (c: any) => {
-        const req = c.request
-        if (!req) return
-
-        const url = new URL(req.url)
-        let pathname = decodeURIComponent(url.pathname)
-
-        // Determine base directory using path discovery
-        let baseDir: string
-
-        // Production: try paths in order of preference
-        if (existsSync('client')) {
-          // Found client/ in current directory (running from dist/)
-          baseDir = 'client'
-        } else if (existsSync('dist/client')) {
-          // Found dist/client/ (running from project root)
-          baseDir = 'dist/client'
-        } else {
-          // Fallback to configured path
-          baseDir = DEFAULTS.publicDir
-        }
-
-        // Root or empty path → index.html
-        if (pathname === '/' || pathname === '') {
-          pathname = `/${DEFAULTS.indexFile}`
-        }
-
-        const filePath = join(baseDir, pathname)
-
-        try {
-          const info = statSync(filePath)
-
-          // File exists → serve it
-          if (info.isFile()) {
-            return Bun.file(filePath)
-          }
-        } catch (_) {
-          // File not found → continue
-        }
-
-        // SPA fallback: serve index.html for non-file routes
-        const indexPath = join(baseDir, DEFAULTS.indexFile)
-        try {
-          statSync(indexPath) // Ensure index exists
-          return Bun.file(indexPath)
-        } catch (_) {
-          // Index not found → let request continue (404)
-        }
-      }
-
-      // Register as catch-all fallback (runs after all other routes)
-      context.app.all('*', staticFallback)
+      context.logger.debug("Production mode: static file serving enabled")
+      context.app.all('*', createStaticFallback())
       return
     }
 
-    // Development mode: import and setup Vite dev server
     const { setupViteDev } = await import('./vite-dev')
     await setupViteDev(context)
   },
 
   onServerStart: async (context: PluginContext) => {
-    if (!DEFAULTS.enabled) return
+    if (!pluginsConfig.viteEnabled) return
 
     if (!isDevelopment()) {
-      context.logger.debug(`Static files ready`, {
-        publicDir: DEFAULTS.publicDir,
-        indexFile: DEFAULTS.indexFile
-      })
+      context.logger.debug('Static files ready')
       return
     }
 
-    const viteConfig = (context as any).viteConfig
-    if (viteConfig) {
-      context.logger.debug(`Vite integration active - monitoring ${viteConfig.host}:${viteConfig.port}`)
-    }
+    context.logger.debug(`Vite active - ${clientConfig.vite.host}:${clientConfig.vite.port}`)
   },
 
-  onBeforeRoute: async (requestContext: RequestContext) => {
-    // Production mode: static serving handled by catch-all route in setup
+  onBeforeRoute: async (ctx: RequestContext) => {
     if (!isDevelopment()) return
 
-    // Skip API routes and swagger - let them be handled by backend
-    if (requestContext.path.startsWith("/api") || requestContext.path.startsWith("/swagger")) {
-      return
-    }
+    const shouldSkip = (pluginsConfig.viteExcludePaths ?? []).some(prefix =>
+      ctx.path === prefix || ctx.path.startsWith(prefix + '/')
+    )
 
-    // For Vite internal routes, proxy directly to Vite server
-    if (requestContext.path.startsWith("/@") ||           // All Vite internal routes (/@vite/, /@fs/, /@react-refresh, etc.)
-      requestContext.path.startsWith("/__vite") ||      // Vite HMR and dev routes
-      requestContext.path.startsWith("/node_modules") || // Direct node_modules access
-      requestContext.path.includes("/.vite/") ||        // Vite cache and deps
-      requestContext.path.endsWith(".js.map") ||        // Source maps
-      requestContext.path.endsWith(".css.map")) {       // CSS source maps
-
-      // Use fixed configuration for Vite proxy
-      const viteHost = "localhost"
-      const vitePort = 5173
-
-      try {
-        const url = parseRequestURL(requestContext.request)
-        const viteUrl = `http://${viteHost}:${vitePort}${requestContext.path}${url.search}`
-
-        // Forward request to Vite
-        const response = await fetch(viteUrl, {
-          method: requestContext.method,
-          headers: requestContext.headers,
-          body: requestContext.method !== 'GET' && requestContext.method !== 'HEAD' ? requestContext.request.body : undefined
-        })
-
-        // Return the Vite response
-        const body = await response.arrayBuffer()
-
-        requestContext.handled = true
-        requestContext.response = new Response(body, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers
-        })
-
-      } catch (viteError) {
-        // If Vite fails, let the request continue to normal routing (will become 404)
-        // Only log if explicitly enabled for debugging
-        if (clientConfig.vite.enableLogging) {
-          console.warn(`Vite proxy error: ${viteError}`)
-        }
-      }
-      return
-    }
-
-    // Use fixed configuration for simplicity - Vite should be running on port 5173
-    const viteHost = "localhost"
-    const vitePort = 5173
-
-    try {
-      const url = parseRequestURL(requestContext.request)
-      const viteUrl = `http://${viteHost}:${vitePort}${requestContext.path}${url.search}`
-
-      // Forward request to Vite
-      const response = await fetch(viteUrl, {
-        method: requestContext.method,
-        headers: requestContext.headers,
-        body: requestContext.method !== 'GET' && requestContext.method !== 'HEAD' ? requestContext.request.body : undefined
-      })
-
-      // If Vite responds successfully, handle the request
-      if (response.ok || response.status < 500) {
-        // Return a proper Response object with all headers and status
-        const body = await response.arrayBuffer()
-
-        requestContext.handled = true
-        requestContext.response = new Response(body, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers
-        })
-      }
-
-    } catch (viteError) {
-      // If Vite fails, let the request continue to normal routing (will become 404)
-      // Only log if explicitly enabled for debugging
-      if (clientConfig.vite.enableLogging) {
-        console.warn(`Vite proxy error: ${viteError}`)
-      }
+    if (!shouldSkip) {
+      await proxyToVite(ctx)
     }
   }
 }
 
-
-export default vitePlugin
+export default vitePlugin

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

@@ -1,33 +1,27 @@
-import type { PluginContext } from "@/core/plugins/types"
-import { clientConfig } from '@/config/client.config'
-
-// Dynamic import type for vite
+import type { PluginContext } from "@core/plugins/types"
+import { clientConfig } from '@config'
+import type { LogLevel } from "vite"
+import conf from "@/vite.config"
+// Dynamic import t@ype for vite
 type ViteDevServer = Awaited<ReturnType<typeof import('vite')['createServer']>>
 
 // Store vite server instance
 let viteServer: ViteDevServer | null = null
 
-// Default configuration values
-const DEFAULTS = {
-  port: clientConfig.vite.port,
-  host: clientConfig.vite.host
-}
-
 /**
  * Setup Vite development server
  * This file is only imported in development mode
  */
 export async function setupViteDev(context: PluginContext): Promise<void> {
-  const vitePort = DEFAULTS.port || clientConfig.vite.port || 5173
-  const viteHost = DEFAULTS.host || "localhost"
-
+  const vitePort = clientConfig.vite.port || 5173
+  const viteHost = clientConfig.vite.host || "localhost"
+  const logLevel = clientConfig.vite.logLevel as LogLevel
   // Import group logger utilities
-  const { endGroup } = await import('@/core/utils/logger/group-logger')
+  const { endGroup } = await import('@core/utils/logger/group-logger')
 
   try {
     // Dynamic import of vite
     const { createServer } = await import('vite')
-
     // Start Vite dev server programmatically (silently)
     viteServer = await createServer({
       configFile: './vite.config.ts',
@@ -36,7 +30,7 @@ export async function setupViteDev(context: PluginContext): Promise<void> {
         host: viteHost,
         strictPort: true
       },
-      logLevel: 'silent'
+      logLevel: logLevel
     })
 
     await viteServer.listen()

package/core/plugins/config.ts

@@ -4,8 +4,8 @@
  */
 
 import type { FluxStack, PluginConfigSchema, PluginValidationResult } from "./types"
-import type { FluxStackConfig } from "@/core/config/schema"
-import type { Logger } from "@/core/utils/logger/index"
+import type { FluxStackConfig } from "@config"
+import type { Logger } from "@core/utils/logger/index"
 
 type Plugin = FluxStack.Plugin
 
@@ -61,19 +61,21 @@ export class DefaultPluginConfigManager implements PluginConfigManager {
 
   /**
    * Get plugin configuration from main config
+   * @deprecated Plugin configs are now directly accessed from config.plugins
    */
   getPluginConfig(pluginName: string, config: FluxStackConfig): any {
-    return config.plugins.config[pluginName] || {}
+    // Plugin configs are now accessed directly from config.plugins
+    // Example: config.plugins.swaggerEnabled
+    return {}
   }
 
   /**
    * Set plugin configuration in main config
+   * @deprecated Plugin configs are now set via environment variables and config files
    */
   setPluginConfig(pluginName: string, pluginConfig: any, config: FluxStackConfig): void {
-    if (!config.plugins.config) {
-      config.plugins.config = {}
-    }
-    config.plugins.config[pluginName] = pluginConfig
+    // Plugin configs are now set via environment variables and config files
+    // This function is deprecated and does nothing
   }
 
   /**

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 '@/core/utils/logger'
+import type { Logger } from '@core/utils/logger'
 
 export interface PluginDependency {
   name: string
@@ -230,6 +230,36 @@ export class PluginDependencyManager {
     }
   }
 
+  /**
+   * Instalar dependências diretamente em um path específico
+   */
+  async installDependenciesInPath(pluginPath: string, dependencies: Record<string, string>): Promise<void> {
+    if (!this.config.autoInstall) {
+      this.logger?.debug('Auto-instalação desabilitada')
+      return
+    }
+
+    if (Object.keys(dependencies).length === 0) {
+      return
+    }
+
+    const pluginDeps: PluginDependency[] = Object.entries(dependencies).map(([name, version]) => ({
+      name,
+      version,
+      type: 'dependency'
+    }))
+
+    this.logger?.debug(`📦 Instalando ${pluginDeps.length} dependência(s) em ${pluginPath}`)
+
+    try {
+      await this.installPluginDependenciesLocally(pluginPath, pluginDeps)
+      this.logger?.debug(`✅ Dependências instaladas com sucesso em ${pluginPath}`)
+    } catch (error) {
+      this.logger?.error(`❌ Erro ao instalar dependências em ${pluginPath}`, { error })
+      throw error
+    }
+  }
+
   /**
    * Encontrar diretório de um plugin pelo nome
    */

package/core/plugins/discovery.ts

@@ -4,7 +4,7 @@
  */
 
 import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
-import type { Logger } from "@/core/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"
@@ -306,12 +306,24 @@ export class PluginDiscovery {
    * Validate if an object is a valid plugin
    */
   private isValidPlugin(plugin: any): plugin is Plugin {
-    return (
-      plugin &&
-      typeof plugin === 'object' &&
-      typeof plugin.name === 'string' &&
-      plugin.name.length > 0
-    )
+    if (!plugin || typeof plugin !== 'object' || typeof plugin.name !== 'string' || plugin.name.length === 0) {
+      return false
+    }
+
+    const hookNames = [
+      'setup', 'onConfigLoad', 'onBeforeServerStart', 'onServerStart',
+      'onAfterServerStart', 'onBeforeServerStop', 'onServerStop',
+      'onRequest', 'onResponse', 'onError'
+    ]
+
+    for (const hook of hookNames) {
+      if (hook in plugin && typeof plugin[hook] !== 'function') {
+        this.logger?.warn(`Plugin "${plugin.name}" has invalid hook "${hook}" (expected function, got ${typeof plugin[hook]})`)
+        return false
+      }
+    }
+
+    return true
   }
 
   /**

package/core/plugins/executor.ts

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