create-fluxstack 1.0.1 → 1.0.3

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

@@ -0,0 +1,316 @@
+import type { Plugin, PluginContext, RequestContext } from "../../types"
+import { createServer, type ViteDevServer } from 'vite'
+
+let viteServer: ViteDevServer | null = null
+
+export const vitePlugin: Plugin = {
+  name: "vite",
+  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
+  category: "development",
+  tags: ["vite", "development", "hot-reload"],
+  dependencies: [], // No dependencies
+  
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        description: "Enable Vite integration"
+      },
+      port: {
+        type: "number",
+        minimum: 1,
+        maximum: 65535,
+        description: "Vite development server port"
+      },
+      host: {
+        type: "string",
+        description: "Vite development server host"
+      },
+      checkInterval: {
+        type: "number",
+        minimum: 100,
+        description: "Interval to check if Vite is running (ms)"
+      },
+      maxRetries: {
+        type: "number",
+        minimum: 1,
+        description: "Maximum retries to connect to Vite"
+      },
+      timeout: {
+        type: "number",
+        minimum: 100,
+        description: "Timeout for Vite requests (ms)"
+      },
+      proxyPaths: {
+        type: "array",
+        items: { type: "string" },
+        description: "Paths to proxy to Vite (defaults to all non-API paths)"
+      },
+      excludePaths: {
+        type: "array", 
+        items: { type: "string" },
+        description: "Paths to exclude from Vite proxying"
+      }
+    },
+    additionalProperties: false
+  },
+  
+  defaultConfig: {
+    enabled: true,
+    port: 5173,
+    host: "localhost",
+    checkInterval: 2000,
+    maxRetries: 10,
+    timeout: 5000,
+    proxyPaths: [],
+    excludePaths: []
+  },
+
+  setup: async (context: PluginContext) => {
+    const config = getPluginConfig(context)
+    
+    if (!config.enabled || !context.config.client) {
+      context.logger.info('Vite plugin disabled or no client configuration found')
+      return
+    }
+    
+    const vitePort = config.port || context.config.client.port || 5173
+    const viteHost = config.host || "localhost"
+    
+    context.logger.info(`🎨 Starting Vite dev server programmatically on ${viteHost}:${vitePort}`)
+    
+    try {
+      // Start Vite dev server programmatically
+      viteServer = await createServer({
+        configFile: './vite.config.ts',
+        // Don't override root - let vite.config.ts handle it
+        server: {
+          port: vitePort,
+          host: viteHost
+        }
+      })
+      
+      await viteServer.listen()
+      viteServer.printUrls()
+      
+      context.logger.info(`✅ Vite server started successfully on ${viteHost}:${vitePort}`)
+      context.logger.info('🔄 Hot reload coordination active - Zero órfãos!')
+      
+      // Store Vite config in context for later use
+      ;(context as any).viteConfig = {
+        port: vitePort,
+        host: viteHost,
+        ...config,
+        server: viteServer
+      }
+      
+      // Setup cleanup on process exit
+      const cleanup = async () => {
+        if (viteServer) {
+          context.logger.info('🛑 Stopping Vite server...')
+          await viteServer.close()
+          viteServer = null
+        }
+      }
+      
+      process.on('SIGINT', cleanup)
+      process.on('SIGTERM', cleanup)
+      process.on('exit', cleanup)
+      
+    } catch (error) {
+      context.logger.error('❌ Failed to start Vite server programmatically:', error)
+      context.logger.info('⚠️ Falling back to monitoring mode...')
+      
+      // Fallback to monitoring if programmatic start fails
+      ;(context as any).viteConfig = {
+        port: vitePort,
+        host: viteHost,
+        ...config
+      }
+      monitorVite(context, viteHost, vitePort, config)
+    }
+  },
+
+  onServerStart: async (context: PluginContext) => {
+    const config = getPluginConfig(context)
+    const viteConfig = (context as any).viteConfig
+    
+    if (config.enabled && viteConfig) {
+      context.logger.info(`Vite integration active - monitoring ${viteConfig.host}:${viteConfig.port}`)
+    }
+  },
+
+  onBeforeRoute: async (requestContext: RequestContext) => {
+    // Skip API routes and swagger - let them be handled by backend
+    if (requestContext.path.startsWith("/api") || requestContext.path.startsWith("/swagger")) {
+      return
+    }
+    
+    // Use fixed configuration for simplicity - Vite should be running on port 5173
+    const viteHost = "localhost"
+    const vitePort = 5173
+    
+    try {
+      const url = new URL(requestContext.request.url)
+      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 (process.env.ENABLE_VITE_PROXY_LOGS === 'true') {
+        console.warn(`Vite proxy error: ${viteError}`)
+      }
+    }
+  }
+}
+
+// Helper function to get plugin config
+function getPluginConfig(context: PluginContext) {
+  const pluginConfig = context.config.plugins.config?.vite || {}
+  return { ...vitePlugin.defaultConfig, ...pluginConfig }
+}
+
+// Monitor Vite server status with automatic port detection
+async function monitorVite(
+  context: PluginContext, 
+  host: string, 
+  initialPort: number, 
+  config: any
+) {
+  let retries = 0
+  let isConnected = false
+  let actualPort = initialPort
+  let portDetected = false
+  
+  const checkVite = async () => {
+    try {
+      // If we haven't found the correct port yet, try to detect it
+      if (!portDetected) {
+        const detectedPort = await detectVitePort(host, initialPort)
+        if (detectedPort !== null) {
+          actualPort = detectedPort
+          portDetected = true
+          // Update the context with the detected port
+          if ((context as any).viteConfig) {
+            ;(context as any).viteConfig.port = actualPort
+          }
+        }
+      }
+      
+      const isRunning = await checkViteRunning(host, actualPort, config.timeout)
+      
+      if (isRunning && !isConnected) {
+        isConnected = true
+        retries = 0
+        if (actualPort !== initialPort) {
+          context.logger.info(`✓ Vite server detected on ${host}:${actualPort} (auto-detected from port ${initialPort})`)
+        } else {
+          context.logger.info(`✓ Vite server detected on ${host}:${actualPort}`)
+        }
+        context.logger.info("Hot reload coordination active")
+      } else if (!isRunning && isConnected) {
+        isConnected = false
+        context.logger.warn(`✗ Vite server disconnected from ${host}:${actualPort}`)
+        // Reset port detection when disconnected
+        portDetected = false
+        actualPort = initialPort
+      } else if (!isRunning) {
+        retries++
+        if (retries <= config.maxRetries) {
+          if (portDetected) {
+            context.logger.debug(`Waiting for Vite server on ${host}:${actualPort}... (${retries}/${config.maxRetries})`)
+          } else {
+            context.logger.debug(`Detecting Vite server port... (${retries}/${config.maxRetries})`)
+          }
+        } else if (retries === config.maxRetries + 1) {
+          context.logger.warn(`Vite server not found after ${config.maxRetries} attempts. Development features may be limited.`)
+        }
+      }
+    } catch (error) {
+      if (isConnected) {
+        context.logger.error('Error checking Vite server status', { error })
+      }
+    }
+    
+    // Continue monitoring
+    setTimeout(checkVite, config.checkInterval)
+  }
+  
+  // Start monitoring after a brief delay
+  setTimeout(checkVite, 1000)
+}
+
+// Auto-detect Vite port by trying common ports
+async function detectVitePort(host: string, startPort: number): Promise<number | null> {
+  // Try the initial port first, then common alternatives
+  const portsToTry = [
+    startPort,
+    startPort + 1,
+    startPort + 2,
+    startPort + 3,
+    5174, // Common Vite alternative
+    5175,
+    5176,
+    3000, // Sometimes Vite might use this
+    4173  // Another common alternative
+  ]
+  
+  for (const port of portsToTry) {
+    try {
+      const isRunning = await checkViteRunning(host, port, 1000)
+      if (isRunning) {
+        return port
+      }
+    } catch (error) {
+      // Continue trying other ports
+    }
+  }
+  
+  return null
+}
+
+// Check if Vite is running
+async function checkViteRunning(host: string, port: number, timeout: number = 1000): Promise<boolean> {
+  try {
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), timeout)
+    
+    const response = await fetch(`http://${host}:${port}`, {
+      signal: controller.signal,
+      method: 'HEAD' // Use HEAD to minimize data transfer
+    })
+    
+    clearTimeout(timeoutId)
+    return response.status >= 200 && response.status < 500
+  } catch (error) {
+    return false
+  }
+}
+
+// Note: Proxy logic is now handled directly in the onBeforeRoute hook above
+
+export default vitePlugin

package/teste-corrigido/core/plugins/config.ts

@@ -0,0 +1,348 @@
+/**
+ * Plugin Configuration Management
+ * Handles plugin-specific configuration validation and management
+ */
+
+import type { Plugin, PluginConfigSchema, PluginValidationResult } from "./types"
+import type { FluxStackConfig } from "../config/schema"
+import type { Logger } from "../utils/logger/index"
+
+export interface PluginConfigManager {
+  validatePluginConfig(plugin: Plugin, config: any): PluginValidationResult
+  mergePluginConfig(plugin: Plugin, userConfig: any): any
+  getPluginConfig(pluginName: string, config: FluxStackConfig): any
+  setPluginConfig(pluginName: string, pluginConfig: any, config: FluxStackConfig): void
+}
+
+export class DefaultPluginConfigManager implements PluginConfigManager {
+  constructor(_logger?: Logger) {
+    // Logger stored but not used in current implementation
+  }
+
+  /**
+   * Validate plugin configuration against its schema
+   */
+  validatePluginConfig(plugin: Plugin, config: any): PluginValidationResult {
+    const result: PluginValidationResult = {
+      valid: true,
+      errors: [],
+      warnings: []
+    }
+
+    if (!plugin.configSchema) {
+      // No schema means any config is valid
+      return result
+    }
+
+    try {
+      this.validateAgainstSchema(config, plugin.configSchema, plugin.name, result)
+    } catch (error) {
+      result.valid = false
+      result.errors.push(`Configuration validation failed: ${error instanceof Error ? error.message : String(error)}`)
+    }
+
+    return result
+  }
+
+  /**
+   * Merge user configuration with plugin defaults
+   */
+  mergePluginConfig(plugin: Plugin, userConfig: any): any {
+    const defaultConfig = plugin.defaultConfig || {}
+    
+    if (!userConfig) {
+      return defaultConfig
+    }
+
+    return this.deepMerge(defaultConfig, userConfig)
+  }
+
+  /**
+   * Get plugin configuration from main config
+   */
+  getPluginConfig(pluginName: string, config: FluxStackConfig): any {
+    return config.plugins.config[pluginName] || {}
+  }
+
+  /**
+   * Set plugin configuration in main config
+   */
+  setPluginConfig(pluginName: string, pluginConfig: any, config: FluxStackConfig): void {
+    if (!config.plugins.config) {
+      config.plugins.config = {}
+    }
+    config.plugins.config[pluginName] = pluginConfig
+  }
+
+  /**
+   * Validate configuration against JSON schema
+   */
+  private validateAgainstSchema(
+    data: any,
+    schema: PluginConfigSchema,
+    pluginName: string,
+    result: PluginValidationResult
+  ): void {
+    if (schema.type === 'object' && typeof data !== 'object') {
+      result.valid = false
+      result.errors.push(`Plugin '${pluginName}' configuration must be an object`)
+      return
+    }
+
+    // Check required properties
+    if (schema.required && Array.isArray(schema.required)) {
+      for (const requiredProp of schema.required) {
+        if (!(requiredProp in data)) {
+          result.valid = false
+          result.errors.push(`Plugin '${pluginName}' configuration missing required property: ${requiredProp}`)
+        }
+      }
+    }
+
+    // Validate properties
+    if (schema.properties) {
+      for (const [propName, propSchema] of Object.entries(schema.properties)) {
+        if (propName in data) {
+          this.validateProperty(data[propName], propSchema, `${pluginName}.${propName}`, result)
+        }
+      }
+    }
+
+    // Check for additional properties
+    if (schema.additionalProperties === false) {
+      const allowedProps = Object.keys(schema.properties || {})
+      const actualProps = Object.keys(data)
+      
+      for (const prop of actualProps) {
+        if (!allowedProps.includes(prop)) {
+          result.warnings.push(`Plugin '${pluginName}' configuration has unexpected property: ${prop}`)
+        }
+      }
+    }
+  }
+
+  /**
+   * Validate individual property
+   */
+  private validateProperty(value: any, schema: any, path: string, result: PluginValidationResult): void {
+    if (schema.type) {
+      const actualType = Array.isArray(value) ? 'array' : typeof value
+      if (actualType !== schema.type) {
+        result.valid = false
+        result.errors.push(`Property '${path}' must be of type ${schema.type}, got ${actualType}`)
+        return
+      }
+    }
+
+    // Type-specific validations
+    switch (schema.type) {
+      case 'string':
+        this.validateStringProperty(value, schema, path, result)
+        break
+      case 'number':
+        this.validateNumberProperty(value, schema, path, result)
+        break
+      case 'array':
+        this.validateArrayProperty(value, schema, path, result)
+        break
+      case 'object':
+        if (schema.properties) {
+          this.validateObjectProperty(value, schema, path, result)
+        }
+        break
+    }
+
+    // Enum validation
+    if (schema.enum && !schema.enum.includes(value)) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must be one of: ${schema.enum.join(', ')}`)
+    }
+  }
+
+  /**
+   * Validate string property
+   */
+  private validateStringProperty(value: string, schema: any, path: string, result: PluginValidationResult): void {
+    if (schema.minLength && value.length < schema.minLength) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must be at least ${schema.minLength} characters long`)
+    }
+
+    if (schema.maxLength && value.length > schema.maxLength) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must be at most ${schema.maxLength} characters long`)
+    }
+
+    if (schema.pattern) {
+      const regex = new RegExp(schema.pattern)
+      if (!regex.test(value)) {
+        result.valid = false
+        result.errors.push(`Property '${path}' does not match required pattern: ${schema.pattern}`)
+      }
+    }
+  }
+
+  /**
+   * Validate number property
+   */
+  private validateNumberProperty(value: number, schema: any, path: string, result: PluginValidationResult): void {
+    if (schema.minimum !== undefined && value < schema.minimum) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must be at least ${schema.minimum}`)
+    }
+
+    if (schema.maximum !== undefined && value > schema.maximum) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must be at most ${schema.maximum}`)
+    }
+
+    if (schema.multipleOf && value % schema.multipleOf !== 0) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must be a multiple of ${schema.multipleOf}`)
+    }
+  }
+
+  /**
+   * Validate array property
+   */
+  private validateArrayProperty(value: any[], schema: any, path: string, result: PluginValidationResult): void {
+    if (schema.minItems && value.length < schema.minItems) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must have at least ${schema.minItems} items`)
+    }
+
+    if (schema.maxItems && value.length > schema.maxItems) {
+      result.valid = false
+      result.errors.push(`Property '${path}' must have at most ${schema.maxItems} items`)
+    }
+
+    if (schema.items) {
+      value.forEach((item, index) => {
+        this.validateProperty(item, schema.items, `${path}[${index}]`, result)
+      })
+    }
+  }
+
+  /**
+   * Validate object property
+   */
+  private validateObjectProperty(value: any, schema: any, path: string, result: PluginValidationResult): void {
+    if (schema.required) {
+      for (const requiredProp of schema.required) {
+        if (!(requiredProp in value)) {
+          result.valid = false
+          result.errors.push(`Property '${path}' missing required property: ${requiredProp}`)
+        }
+      }
+    }
+
+    if (schema.properties) {
+      for (const [propName, propSchema] of Object.entries(schema.properties)) {
+        if (propName in value) {
+          this.validateProperty(value[propName], propSchema, `${path}.${propName}`, result)
+        }
+      }
+    }
+  }
+
+  /**
+   * Deep merge two objects
+   */
+  private deepMerge(target: any, source: any): any {
+    if (source === null || source === undefined) {
+      return target
+    }
+
+    if (target === null || target === undefined) {
+      return source
+    }
+
+    if (typeof target !== 'object' || typeof source !== 'object') {
+      return source
+    }
+
+    if (Array.isArray(source)) {
+      return [...source]
+    }
+
+    const result = { ...target }
+
+    for (const key in source) {
+      if (source.hasOwnProperty(key)) {
+        if (typeof source[key] === 'object' && !Array.isArray(source[key]) && source[key] !== null) {
+          result[key] = this.deepMerge(target[key], source[key])
+        } else {
+          result[key] = source[key]
+        }
+      }
+    }
+
+    return result
+  }
+}
+
+/**
+ * Create plugin configuration utilities
+ */
+export function createPluginUtils(logger?: Logger): PluginUtils {
+  return {
+    createTimer: (label: string) => {
+      const start = Date.now()
+      return {
+        end: () => {
+          const duration = Date.now() - start
+          logger?.debug(`Timer '${label}' completed`, { duration })
+          return duration
+        }
+      }
+    },
+
+    formatBytes: (bytes: number): string => {
+      if (bytes === 0) return '0 Bytes'
+      const k = 1024
+      const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
+      const i = Math.floor(Math.log(bytes) / Math.log(k))
+      return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+    },
+
+    isProduction: (): boolean => {
+      return process.env.NODE_ENV === 'production'
+    },
+
+    isDevelopment: (): boolean => {
+      return process.env.NODE_ENV === 'development'
+    },
+
+    getEnvironment: (): string => {
+      return process.env.NODE_ENV || 'development'
+    },
+
+    createHash: (data: string): string => {
+      // Simple hash function - in production, use crypto
+      let hash = 0
+      for (let i = 0; i < data.length; i++) {
+        const char = data.charCodeAt(i)
+        hash = ((hash << 5) - hash) + char
+        hash = hash & hash // Convert to 32-bit integer
+      }
+      return hash.toString(36)
+    },
+
+    deepMerge: (target: any, source: any): any => {
+      const manager = new DefaultPluginConfigManager()
+      return (manager as any).deepMerge(target, source)
+    },
+
+    validateSchema: (data: any, schema: any): { valid: boolean; errors: string[] } => {
+      const manager = new DefaultPluginConfigManager()
+      const result = manager.validatePluginConfig({ name: 'temp', configSchema: schema }, data)
+      return {
+        valid: result.valid,
+        errors: result.errors
+      }
+    }
+  }
+}
+
+// Export types for plugin utilities
+import type { PluginUtils } from "./types"