create-fluxstack 1.0.22 → 1.4.0

package/core/build/live-components-generator.ts

@@ -0,0 +1,231 @@
+// 🚀 FluxStack Live Components - Auto Registration Generator
+// Automatically generates component registration during build time
+
+import { existsSync, readdirSync, writeFileSync, unlinkSync, readFileSync } from 'fs'
+import { join, extname, basename } from 'path'
+
+export interface ComponentInfo {
+  fileName: string
+  className: string
+  componentName: string
+  filePath: string
+}
+
+export class LiveComponentsGenerator {
+  private componentsPath: string
+  private registrationFilePath: string
+  private backupFilePath: string
+
+  constructor() {
+    this.componentsPath = join(process.cwd(), 'app', 'server', 'live')
+    this.registrationFilePath = join(process.cwd(), 'app', 'server', 'live', 'register-components.ts')
+    this.backupFilePath = join(process.cwd(), 'app', 'server', 'live', 'register-components.backup.ts')
+  }
+
+  /**
+   * Scan the live components directory and discover all components
+   */
+  discoverComponents(): ComponentInfo[] {
+    if (!existsSync(this.componentsPath)) {
+      console.log('⚠️ Live components directory not found:', this.componentsPath)
+      return []
+    }
+
+    const components: ComponentInfo[] = []
+    const files = readdirSync(this.componentsPath)
+
+    for (const file of files) {
+      // Skip non-TypeScript files, backup files, and the registration file itself
+      if (!file.endsWith('.ts') || 
+          file === 'register-components.ts' || 
+          file.includes('.backup.') ||
+          file.includes('.bak')) {
+        continue
+      }
+
+      const filePath = join(this.componentsPath, file)
+      const fileName = basename(file, extname(file))
+      
+      try {
+        // Read file content to extract class name
+        const content = readFileSync(filePath, 'utf-8')
+        
+        // Look for class exports that extend LiveComponent
+        const classMatches = content.match(/export\s+class\s+(\w+)\s+extends\s+LiveComponent/g)
+        
+        if (classMatches && classMatches.length > 0) {
+          for (const match of classMatches) {
+            const classNameMatch = match.match(/class\s+(\w+)/)
+            if (classNameMatch) {
+              const className = classNameMatch[1]
+              const componentName = className.replace(/Component$/, '')
+              
+              components.push({
+                fileName,
+                className,
+                componentName,
+                filePath: `./${fileName}`
+              })
+              
+              console.log(`🔍 Discovered component: ${className} -> ${componentName}`)
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ Failed to analyze ${file}:`, error)
+      }
+    }
+
+    return components
+  }
+
+  /**
+   * Generate the registration file with all discovered components
+   */
+  generateRegistrationFile(components: ComponentInfo[]): void {
+    // Backup existing file if it exists
+    if (existsSync(this.registrationFilePath)) {
+      const existingContent = readFileSync(this.registrationFilePath, 'utf-8')
+      writeFileSync(this.backupFilePath, existingContent)
+      console.log('📄 Backed up existing register-components.ts')
+    }
+
+    // Generate imports
+    const imports = components
+      .map(comp => `import { ${comp.className} } from "${comp.filePath}"`)
+      .join('\n')
+
+    // Generate registrations
+    const registrations = components
+      .map(comp => `    componentRegistry.registerComponentClass('${comp.componentName}', ${comp.className})`)
+      .join('\n')
+
+    // Generate file content
+    const fileContent = `// 🔥 Auto-generated Live Components Registration
+// This file is automatically generated during build time - DO NOT EDIT MANUALLY
+// Generated at: ${new Date().toISOString()}
+
+${imports}
+import { componentRegistry } from "@/core/server/live/ComponentRegistry"
+
+// Register all components statically for production bundle
+function registerAllComponents() {
+  try {
+    // Auto-generated component registrations
+${registrations}
+    
+    console.log('📝 Live components registered successfully! (${components.length} components)')
+  } catch (error) {
+    console.warn('⚠️ Error registering components:', error)
+  }
+}
+
+// Auto-register components
+registerAllComponents()
+
+// Export all components to ensure they're included in the bundle
+export { 
+${components.map(comp => `  ${comp.className}`).join(',\n')}
+}
+`
+
+    writeFileSync(this.registrationFilePath, fileContent)
+    console.log(`✅ Generated registration file with ${components.length} components`)
+  }
+
+  /**
+   * Restore the original registration file from backup
+   */
+  restoreOriginalFile(): void {
+    if (existsSync(this.backupFilePath)) {
+      const backupContent = readFileSync(this.backupFilePath, 'utf-8')
+      writeFileSync(this.registrationFilePath, backupContent)
+      unlinkSync(this.backupFilePath)
+      console.log('🔄 Restored original register-components.ts')
+    } else {
+      console.log('⚠️ No backup file found, keeping generated registration file')
+    }
+  }
+
+  /**
+   * Check if the current registration file is auto-generated
+   */
+  isAutoGenerated(): boolean {
+    if (!existsSync(this.registrationFilePath)) {
+      return false
+    }
+
+    const content = readFileSync(this.registrationFilePath, 'utf-8')
+    return content.includes('// 🔥 Auto-generated Live Components Registration')
+  }
+
+  /**
+   * Pre-build hook: Generate registration file
+   */
+  async preBuild(): Promise<ComponentInfo[]> {
+    console.log('🚀 [PRE-BUILD] Generating Live Components registration...')
+    
+    const components = this.discoverComponents()
+    
+    if (components.length === 0) {
+      console.log('⚠️ No Live Components found to register')
+      return []
+    }
+
+    this.generateRegistrationFile(components)
+    
+    return components
+  }
+
+  /**
+   * Post-build hook: Clean up generated file (optional)
+   */
+  async postBuild(keepGenerated: boolean = false): Promise<void> {
+    console.log('🧹 [POST-BUILD] Cleaning up Live Components registration...')
+    
+    if (keepGenerated) {
+      console.log('📝 Keeping auto-generated registration file for production')
+      // Remove backup since we're keeping the generated version
+      if (existsSync(this.backupFilePath)) {
+        unlinkSync(this.backupFilePath)
+      }
+    } else {
+      this.restoreOriginalFile()
+    }
+  }
+
+  /**
+   * Development mode: Check if registration needs update
+   */
+  needsUpdate(): boolean {
+    if (!this.isAutoGenerated()) {
+      return false // Manual file, don't touch
+    }
+
+    const components = this.discoverComponents()
+    const currentContent = readFileSync(this.registrationFilePath, 'utf-8')
+    
+    // Check if all discovered components are in the current file
+    for (const comp of components) {
+      if (!currentContent.includes(`'${comp.componentName}', ${comp.className}`)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Development mode: Update registration if needed
+   */
+  updateIfNeeded(): void {
+    if (this.needsUpdate()) {
+      console.log('🔄 Live Components changed, updating registration...')
+      const components = this.discoverComponents()
+      this.generateRegistrationFile(components)
+    }
+  }
+}
+
+// Export singleton instance
+export const liveComponentsGenerator = new LiveComponentsGenerator()

package/core/build/optimizer.ts

@@ -4,7 +4,6 @@ import { gzipSync } from "zlib"
 import type { OptimizationConfig, OptimizationResult } from "../types/build"
 
 export interface OptimizerConfig {
-  minify: boolean
   treeshake: boolean
   compress: boolean
   removeUnusedCSS: boolean
@@ -36,10 +35,7 @@ export class Optimizer {
       // Get original size
       results.originalSize = await this.calculateDirectorySize(buildPath)
 
-      // Apply optimizations
-      if (this.config.minify) {
-        await this.minifyAssets(buildPath, results)
-      }
+      // Apply optimizations (minification removed for compatibility)
 
       if (this.config.compress) {
         await this.compressAssets(buildPath, results)
@@ -80,55 +76,7 @@ export class Optimizer {
     }
   }
 
-  private async minifyAssets(buildPath: string, results: OptimizationResult): Promise<void> {
-    console.log("🗜️ Minifying assets...")
-    
-    const files = this.getFilesRecursively(buildPath)
-    let minifiedCount = 0
-
-    for (const file of files) {
-      const ext = extname(file).toLowerCase()
-      
-      if (ext === '.js' || ext === '.css') {
-        try {
-          const content = readFileSync(file, 'utf-8')
-          const minified = await this.minifyContent(content, ext)
-          
-          if (minified !== content) {
-            writeFileSync(file, minified)
-            minifiedCount++
-          }
-        } catch (error) {
-          console.warn(`⚠️ Failed to minify ${file}:`, error)
-        }
-      }
-    }
-
-    results.optimizations.push({
-      type: 'minification',
-      description: `Minified ${minifiedCount} files`,
-      sizeSaved: 0 // Would calculate actual size saved
-    })
-  }
-
-  private async minifyContent(content: string, type: string): Promise<string> {
-    // Basic minification - in a real implementation, you'd use proper minifiers
-    if (type === '.js') {
-      return content
-        .replace(/\/\*[\s\S]*?\*\//g, '') // Remove comments
-        .replace(/\/\/.*$/gm, '') // Remove single-line comments
-        .replace(/\s+/g, ' ') // Collapse whitespace
-        .trim()
-    } else if (type === '.css') {
-      return content
-        .replace(/\/\*[\s\S]*?\*\//g, '') // Remove comments
-        .replace(/\s+/g, ' ') // Collapse whitespace
-        .replace(/;\s*}/g, '}') // Remove unnecessary semicolons
-        .trim()
-    }
-    
-    return content
-  }
+  // Minification methods removed for compatibility with Bun bundler
 
   private async compressAssets(buildPath: string, results: OptimizationResult): Promise<void> {
     console.log("📦 Compressing assets...")

package/core/cli/index.ts

@@ -6,6 +6,7 @@ import { getConfigSync } from "../config"
 import { cliRegistry } from "./command-registry"
 import { pluginDiscovery } from "./plugin-discovery"
 import { generateCommand, interactiveGenerateCommand } from "./generators/index.js"
+import { startGroup, endGroup, logBox, logInGroup } from "../utils/logger/group-logger"
 
 const command = process.argv[2]
 const args = process.argv.slice(3)
@@ -134,12 +135,20 @@ Examples:
       }
     ],
     handler: async (args, options, context) => {
-      console.log("⚡ FluxStack Full-Stack Development")
-      console.log(`🌐 Frontend: http://localhost:${options['frontend-port']}`)  
-      console.log(`🚀 Backend: http://localhost:${options.port}`)
-      console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-      console.log("📦 Starting backend server...")
-      console.log()
+      // Grouped startup messages
+      startGroup({
+        title: 'FluxStack Development Server',
+        icon: '⚡',
+        color: 'cyan'
+      })
+
+      logInGroup(`Frontend: http://localhost:${options['frontend-port']}`, '🌐')
+      logInGroup(`Backend: http://localhost:${options.port}`, '🚀')
+      logInGroup('Backend inicia Vite programaticamente', '🔄')
+      logInGroup('Starting backend server...', '📦')
+
+      endGroup()
+      console.log('') // Separator line
       
       const { spawn } = await import("child_process")
       const devProcess = spawn("bun", ["--watch", "app/server/index.ts"], {
@@ -293,12 +302,20 @@ async function main() {
 async function handleLegacyCommands() {
   switch (command) {
   case "dev":
-    console.log("⚡ FluxStack Full-Stack Development")
-    console.log("🌐 Frontend: http://localhost:5173")  
-    console.log("🚀 Backend: http://localhost:3000")
-    console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-    console.log("📦 Starting backend server...")
-    console.log()
+    // Grouped startup messages
+    startGroup({
+      title: 'FluxStack Development Server',
+      icon: '⚡',
+      color: 'cyan'
+    })
+
+    logInGroup('Frontend: http://localhost:5173', '🌐')
+    logInGroup('Backend: http://localhost:3000', '🚀')
+    logInGroup('Backend inicia Vite programaticamente', '🔄')
+    logInGroup('Starting backend server...', '📦')
+
+    endGroup()
+    console.log('') // Separator line
     
     // Start only backend - it will start Vite programmatically
     const { spawn } = await import("child_process")
@@ -385,7 +402,8 @@ async function handleLegacyCommands() {
 
   case "start":
     console.log("🚀 Starting FluxStack production server...")
-    await import(process.cwd() + "/dist/index.js")
+    const { join } = await import("path")
+    await import(join(process.cwd(), "dist", "index.js"))
     break
 
   case "create":

package/core/config/env.ts

@@ -3,6 +3,7 @@
  * Handles environment variable processing and precedence
  */
 
+import { env, helpers } from '../utils/env'
 import type { FluxStackConfig, LogLevel, BuildTarget, LogFormat } from './schema'
 
 export interface EnvironmentInfo {
@@ -24,7 +25,7 @@ export interface ConfigPrecedence {
  * Get current environment information
  */
 export function getEnvironmentInfo(): EnvironmentInfo {
-  const nodeEnv = process.env.NODE_ENV || 'development'
+  const nodeEnv = env.NODE_ENV
 
   return {
     name: nodeEnv,
@@ -97,117 +98,60 @@ export class EnvironmentProcessor {
     const config: any = {}
 
     // App configuration
-    this.setConfigValue(config, 'app.name',
-      process.env.FLUXSTACK_APP_NAME || process.env.APP_NAME, 'string')
-    this.setConfigValue(config, 'app.version',
-      process.env.FLUXSTACK_APP_VERSION || process.env.APP_VERSION, 'string')
-    this.setConfigValue(config, 'app.description',
-      process.env.FLUXSTACK_APP_DESCRIPTION || process.env.APP_DESCRIPTION, 'string')
+    this.setConfigValue(config, 'app.name', env.FLUXSTACK_APP_NAME, 'string')
+    this.setConfigValue(config, 'app.version', env.FLUXSTACK_APP_VERSION, 'string')
 
     // Server configuration
-    this.setConfigValue(config, 'server.port',
-      process.env.PORT || process.env.FLUXSTACK_PORT, 'number')
-    this.setConfigValue(config, 'server.host',
-      process.env.HOST || process.env.FLUXSTACK_HOST, 'string')
-    this.setConfigValue(config, 'server.apiPrefix',
-      process.env.FLUXSTACK_API_PREFIX || process.env.API_PREFIX, 'string')
+    this.setConfigValue(config, 'server.port', env.PORT?.toString(), 'number')
+    this.setConfigValue(config, 'server.host', env.HOST, 'string')
+    this.setConfigValue(config, 'server.apiPrefix', env.API_PREFIX, 'string')
 
     // CORS configuration
-    this.setConfigValue(config, 'server.cors.origins',
-      process.env.CORS_ORIGINS || process.env.FLUXSTACK_CORS_ORIGINS, 'array')
-    this.setConfigValue(config, 'server.cors.methods',
-      process.env.CORS_METHODS || process.env.FLUXSTACK_CORS_METHODS, 'array')
-    this.setConfigValue(config, 'server.cors.headers',
-      process.env.CORS_HEADERS || process.env.FLUXSTACK_CORS_HEADERS, 'array')
-    this.setConfigValue(config, 'server.cors.credentials',
-      process.env.CORS_CREDENTIALS || process.env.FLUXSTACK_CORS_CREDENTIALS, 'boolean')
-    this.setConfigValue(config, 'server.cors.maxAge',
-      process.env.CORS_MAX_AGE || process.env.FLUXSTACK_CORS_MAX_AGE, 'number')
+    const corsOriginsStr = env.has('CORS_ORIGINS') ? env.all().CORS_ORIGINS : undefined
+    const corsMethodsStr = env.has('CORS_METHODS') ? env.all().CORS_METHODS : undefined
+    const corsHeadersStr = env.has('CORS_HEADERS') ? env.all().CORS_HEADERS : undefined
+
+    this.setConfigValue(config, 'server.cors.origins', corsOriginsStr, 'array')
+    this.setConfigValue(config, 'server.cors.methods', corsMethodsStr, 'array')
+    this.setConfigValue(config, 'server.cors.headers', corsHeadersStr, 'array')
+    this.setConfigValue(config, 'server.cors.credentials', env.CORS_CREDENTIALS?.toString(), 'boolean')
+    this.setConfigValue(config, 'server.cors.maxAge', env.CORS_MAX_AGE?.toString(), 'number')
 
     // Client configuration
-    this.setConfigValue(config, 'client.port',
-      process.env.VITE_PORT || process.env.CLIENT_PORT || process.env.FLUXSTACK_CLIENT_PORT, 'number')
-    this.setConfigValue(config, 'client.proxy.target',
-      process.env.VITE_API_URL || process.env.API_URL || process.env.FLUXSTACK_PROXY_TARGET, 'string')
-    this.setConfigValue(config, 'client.build.sourceMaps',
-      process.env.FLUXSTACK_CLIENT_SOURCEMAPS, 'boolean')
-    this.setConfigValue(config, 'client.build.minify',
-      process.env.FLUXSTACK_CLIENT_MINIFY, 'boolean')
+    this.setConfigValue(config, 'client.port', env.VITE_PORT?.toString(), 'number')
 
     // Build configuration
-    this.setConfigValue(config, 'build.target',
-      process.env.BUILD_TARGET || process.env.FLUXSTACK_BUILD_TARGET, 'buildTarget')
-    this.setConfigValue(config, 'build.outDir',
-      process.env.BUILD_OUTDIR || process.env.FLUXSTACK_BUILD_OUTDIR, 'string')
-    this.setConfigValue(config, 'build.sourceMaps',
-      process.env.BUILD_SOURCEMAPS || process.env.FLUXSTACK_BUILD_SOURCEMAPS, 'boolean')
-    this.setConfigValue(config, 'build.clean',
-      process.env.BUILD_CLEAN || process.env.FLUXSTACK_BUILD_CLEAN, 'boolean')
-
-    // Build optimization
-    this.setConfigValue(config, 'build.optimization.minify',
-      process.env.BUILD_MINIFY || process.env.FLUXSTACK_BUILD_MINIFY, 'boolean')
-    this.setConfigValue(config, 'build.optimization.treeshake',
-      process.env.BUILD_TREESHAKE || process.env.FLUXSTACK_BUILD_TREESHAKE, 'boolean')
-    this.setConfigValue(config, 'build.optimization.compress',
-      process.env.BUILD_COMPRESS || process.env.FLUXSTACK_BUILD_COMPRESS, 'boolean')
-    this.setConfigValue(config, 'build.optimization.splitChunks',
-      process.env.BUILD_SPLIT_CHUNKS || process.env.FLUXSTACK_BUILD_SPLIT_CHUNKS, 'boolean')
-    this.setConfigValue(config, 'build.optimization.bundleAnalyzer',
-      process.env.BUILD_ANALYZER || process.env.FLUXSTACK_BUILD_ANALYZER, 'boolean')
+    const buildMinify = env.has('BUILD_MINIFY') ? env.all().BUILD_MINIFY : undefined
+    this.setConfigValue(config, 'build.optimization.minify', buildMinify, 'boolean')
 
     // Logging configuration
-    this.setConfigValue(config, 'logging.level',
-      process.env.LOG_LEVEL || process.env.FLUXSTACK_LOG_LEVEL, 'logLevel')
-    this.setConfigValue(config, 'logging.format',
-      process.env.LOG_FORMAT || process.env.FLUXSTACK_LOG_FORMAT, 'logFormat')
+    this.setConfigValue(config, 'logging.level', env.LOG_LEVEL, 'logLevel')
+    this.setConfigValue(config, 'logging.format', env.LOG_FORMAT, 'logFormat')
 
     // Monitoring configuration
-    this.setConfigValue(config, 'monitoring.enabled',
-      process.env.MONITORING_ENABLED || process.env.FLUXSTACK_MONITORING_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.metrics.enabled',
-      process.env.METRICS_ENABLED || process.env.FLUXSTACK_METRICS_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.metrics.collectInterval',
-      process.env.METRICS_INTERVAL || process.env.FLUXSTACK_METRICS_INTERVAL, 'number')
-    this.setConfigValue(config, 'monitoring.profiling.enabled',
-      process.env.PROFILING_ENABLED || process.env.FLUXSTACK_PROFILING_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.profiling.sampleRate',
-      process.env.PROFILING_SAMPLE_RATE || process.env.FLUXSTACK_PROFILING_SAMPLE_RATE, 'number')
+    this.setConfigValue(config, 'monitoring.enabled', env.ENABLE_MONITORING?.toString(), 'boolean')
+    this.setConfigValue(config, 'monitoring.metrics.enabled', env.ENABLE_METRICS?.toString(), 'boolean')
 
     // Database configuration
-    this.setConfigValue(config, 'database.url', process.env.DATABASE_URL, 'string')
-    this.setConfigValue(config, 'database.host', process.env.DATABASE_HOST, 'string')
-    this.setConfigValue(config, 'database.port', process.env.DATABASE_PORT, 'number')
-    this.setConfigValue(config, 'database.database', process.env.DATABASE_NAME, 'string')
-    this.setConfigValue(config, 'database.user', process.env.DATABASE_USER, 'string')
-    this.setConfigValue(config, 'database.password', process.env.DATABASE_PASSWORD, 'string')
-    this.setConfigValue(config, 'database.ssl', process.env.DATABASE_SSL, 'boolean')
-    this.setConfigValue(config, 'database.poolSize', process.env.DATABASE_POOL_SIZE, 'number')
+    this.setConfigValue(config, 'database.url', env.DATABASE_URL, 'string')
+    this.setConfigValue(config, 'database.host', env.DB_HOST, 'string')
+    this.setConfigValue(config, 'database.port', env.DB_PORT?.toString(), 'number')
+    this.setConfigValue(config, 'database.database', env.DB_NAME, 'string')
+    this.setConfigValue(config, 'database.user', env.DB_USER, 'string')
+    this.setConfigValue(config, 'database.password', env.DB_PASSWORD, 'string')
+    this.setConfigValue(config, 'database.ssl', env.DB_SSL?.toString(), 'boolean')
 
     // Auth configuration
-    this.setConfigValue(config, 'auth.secret', process.env.JWT_SECRET, 'string')
-    this.setConfigValue(config, 'auth.expiresIn', process.env.JWT_EXPIRES_IN, 'string')
-    this.setConfigValue(config, 'auth.algorithm', process.env.JWT_ALGORITHM, 'string')
-    this.setConfigValue(config, 'auth.issuer', process.env.JWT_ISSUER, 'string')
+    this.setConfigValue(config, 'auth.secret', env.JWT_SECRET, 'string')
+    this.setConfigValue(config, 'auth.expiresIn', env.JWT_EXPIRES_IN, 'string')
+    this.setConfigValue(config, 'auth.algorithm', env.JWT_ALGORITHM, 'string')
 
     // Email configuration
-    this.setConfigValue(config, 'email.host', process.env.SMTP_HOST, 'string')
-    this.setConfigValue(config, 'email.port', process.env.SMTP_PORT, 'number')
-    this.setConfigValue(config, 'email.user', process.env.SMTP_USER, 'string')
-    this.setConfigValue(config, 'email.password', process.env.SMTP_PASSWORD, 'string')
-    this.setConfigValue(config, 'email.secure', process.env.SMTP_SECURE, 'boolean')
-    this.setConfigValue(config, 'email.from', process.env.SMTP_FROM, 'string')
-
-    // Storage configuration
-    this.setConfigValue(config, 'storage.uploadPath', process.env.UPLOAD_PATH, 'string')
-    this.setConfigValue(config, 'storage.maxFileSize', process.env.MAX_FILE_SIZE, 'number')
-    this.setConfigValue(config, 'storage.provider', process.env.STORAGE_PROVIDER, 'string')
-
-    // Plugin configuration
-    this.setConfigValue(config, 'plugins.enabled',
-      process.env.FLUXSTACK_PLUGINS_ENABLED, 'array')
-    this.setConfigValue(config, 'plugins.disabled',
-      process.env.FLUXSTACK_PLUGINS_DISABLED, 'array')
+    this.setConfigValue(config, 'email.host', env.SMTP_HOST, 'string')
+    this.setConfigValue(config, 'email.port', env.SMTP_PORT?.toString(), 'number')
+    this.setConfigValue(config, 'email.user', env.SMTP_USER, 'string')
+    this.setConfigValue(config, 'email.password', env.SMTP_PASSWORD, 'string')
+    this.setConfigValue(config, 'email.secure', env.SMTP_SECURE?.toString(), 'boolean')
 
     return this.cleanEmptyObjects(config)
   }