create-fluxstack 1.0.4 → 1.0.6

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

@@ -1,316 +0,0 @@
-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/meu-app-teste/core/plugins/config.ts

@@ -1,348 +0,0 @@
-/**
- * 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"