create-fluxstack 1.1.0 → 1.4.0

package/app/server/backend-only.ts

@@ -1,15 +1,15 @@
 // Backend standalone entry point
 import { startBackendOnly } from "@/core/server/standalone"
 import { apiRoutes } from "./routes"
-import { env } from "@/core/utils/env-runtime"
+import { serverConfig } from "@/config/server.config"
 
-// Configuração para backend standalone com env dinâmico
+// Configuração para backend standalone usando config declarativo
 const backendConfig = {
-  port: env.get('BACKEND_PORT', 3001),  // Casting automático para number
-  apiPrefix: env.API_PREFIX             // Direto! (string)
+  port: serverConfig.backendPort,
+  apiPrefix: serverConfig.apiPrefix
 }
 
-console.log(`🚀 Backend standalone: ${env.HOST}:${backendConfig.port}`)
+console.log(`🚀 Backend standalone: ${serverConfig.host}:${backendConfig.port}`)
 
 // Iniciar apenas o backend
 startBackendOnly(apiRoutes, backendConfig)

package/app/server/index.ts

@@ -1,52 +1,54 @@
 // User application entry point
-import { FluxStackFramework, loggerPlugin, vitePlugin, swaggerPlugin, staticPlugin, liveComponentsPlugin, staticFilesPlugin } from "@/core/server"
+import { FluxStackFramework, vitePlugin, swaggerPlugin, staticPlugin, liveComponentsPlugin, staticFilesPlugin } from "@/core/server"
 import { isDevelopment } from "@/core/utils/helpers"
+import { DEBUG } from "@/core/utils/logger"
 import { apiRoutes } from "./routes"
-// Import sistema de env dinâmico simplificado
-import { env, helpers } from "@/core/utils/env-runtime-v2"
-// Import live components registration
+import { helpers } from "@/core/utils/env"
+import { serverConfig } from "@/config/server.config"
+import { appConfig } from "@/config/app.config"
+import { loggerConfig } from "@/config/logger.config"
 import "./live/register-components"
 
-console.log('🔧 Loading dynamic environment configuration...')
-console.log(`📊 Environment: ${env.NODE_ENV}`)           // Direto!
-console.log(`🚀 Port: ${env.PORT}`)                      // Direto!
-console.log(`🌐 Host: ${env.HOST}`)                      // Direto!
+// Startup info moved to DEBUG level (set LOG_LEVEL=debug to see details)
+DEBUG('🔧 Loading declarative configuration...')
+DEBUG(`📊 Environment: ${appConfig.env}`)
+DEBUG(`🚀 Port: ${serverConfig.port}`)
+DEBUG(`🌐 Host: ${serverConfig.host}`)
 
-// Criar aplicação com configuração dinâmica simplificada
+// Criar aplicação com configuração declarativa
 const app = new FluxStackFramework({
   server: {
-    port: env.PORT,                      // Direto! (number)
-    host: env.HOST,                      // Direto! (string)
-    apiPrefix: env.API_PREFIX,           // Direto! (string)
+    port: serverConfig.port,
+    host: serverConfig.host,
+    apiPrefix: serverConfig.apiPrefix,
     cors: {
-      origins: env.CORS_ORIGINS,         // Direto! (string[])
-      methods: env.get('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
-      headers: env.get('CORS_HEADERS', ['*']),
-      credentials: env.get('CORS_CREDENTIALS', false)
+      origins: serverConfig.corsOrigins,
+      methods: serverConfig.corsMethods,
+      headers: serverConfig.corsHeaders,
+      credentials: serverConfig.corsCredentials
     },
     middleware: []
   },
   app: {
-    name: env.FLUXSTACK_APP_NAME,        // Direto! (string)
-    version: env.FLUXSTACK_APP_VERSION   // Direto! (string)
+    name: serverConfig.appName,
+    version: serverConfig.appVersion
   },
   client: {
-    port: env.VITE_PORT,                 // Direto! (number)
+    port: serverConfig.clientPort,
     proxy: {
-      target: helpers.getServerUrl()     // Helper inteligente
+      target: helpers.getServerUrl()
     },
     build: {
-      sourceMaps: env.get('CLIENT_SOURCEMAPS', env.NODE_ENV !== 'production'),
-      minify: env.get('CLIENT_MINIFY', env.NODE_ENV === 'production'),
-      target: env.get('CLIENT_TARGET', 'es2020'),
-      outDir: env.get('CLIENT_OUTDIR', 'dist')
+      sourceMaps: serverConfig.clientSourceMaps,
+      minify: false,
+      target: serverConfig.clientTarget as any,
+      outDir: serverConfig.clientOutDir
     }
   }
 })
 
 
-// Usar plugins de infraestrutura primeiro (mas NÃO o Swagger ainda)
-app.use(loggerPlugin)
+// Usar plugins de infraestrutura primeiro (Logger é core, não é plugin)
 
 // Usar plugins condicionalmente baseado no ambiente
 if (isDevelopment()) {
@@ -60,30 +62,47 @@ app.use(staticFilesPlugin) // Add Static Files support
 app.use(liveComponentsPlugin) // Add Live Components support
   
 
-// Adicionar rota de teste para mostrar env dinâmico (antes das rotas)
+// Adicionar rota de teste para mostrar config declarativo (antes das rotas)
 app.getApp().get('/api/env-test', () => {
   return {
-    message: '🔥 Environment Variables Simplificado!',
+    message: '⚡ Declarative Config System!',
     timestamp: new Date().toISOString(),
+    serverConfig: {
+      port: serverConfig.port,
+      host: serverConfig.host,
+      apiPrefix: serverConfig.apiPrefix,
+      appName: serverConfig.appName,
+      appVersion: serverConfig.appVersion,
+      cors: {
+        origins: serverConfig.corsOrigins,
+        methods: serverConfig.corsMethods,
+        credentials: serverConfig.corsCredentials
+      },
+      client: {
+        port: serverConfig.clientPort,
+        target: serverConfig.clientTarget,
+        sourceMaps: serverConfig.clientSourceMaps
+      },
+      features: {
+        enableSwagger: serverConfig.enableSwagger,
+        enableMetrics: serverConfig.enableMetrics,
+        enableMonitoring: serverConfig.enableMonitoring
+      }
+    },
     environment: {
-      NODE_ENV: env.NODE_ENV,             // Direto!
-      PORT: env.PORT,                     // Direto!
-      HOST: env.HOST,                     // Direto!
-      DEBUG: env.DEBUG,                   // Direto!
-      CORS_ORIGINS: env.CORS_ORIGINS,     // Direto!
-      ENABLE_SWAGGER: env.ENABLE_SWAGGER, // Direto!
-      
-      // Vars customizadas com casting automático
-      CUSTOM_VAR: env.get('CUSTOM_VAR', 'not-set'),
-      MAX_RETRIES: env.get('MAX_RETRIES', 3),        // number
-      ENABLE_CACHE: env.get('ENABLE_CACHE', false),  // boolean
-      ALLOWED_IPS: env.get('ALLOWED_IPS', [])        // string[]
+      NODE_ENV: appConfig.env,
+      DEBUG: appConfig.debug,
+      LOG_LEVEL: loggerConfig.level
     },
     urls: {
-      server: helpers.getServerUrl(),     // Helper!
+      server: helpers.getServerUrl(),
+      client: helpers.getClientUrl(),
       swagger: `${helpers.getServerUrl()}/swagger`
     },
-    note: 'API simplificada com casting automático! 🚀'
+    system: {
+      version: 'declarative-config',
+      features: ['type-safe', 'validated', 'declarative', 'runtime-reload']
+    }
   }
 })
 
@@ -93,18 +112,8 @@ app.routes(apiRoutes)
 // Swagger por último para descobrir todas as rotas
 app.use(swaggerPlugin)
 
-// Iniciar servidor
-app.listen(() => {
-  console.log('\n✅ FluxStack com Environment Variables Simplificado!')
-  console.log(`🔗 Server: ${helpers.getServerUrl()}`)
-  console.log(`🔗 Teste dinâmico: ${helpers.getServerUrl()}/api/env-test`)
-  
-  if (env.ENABLE_SWAGGER) {
-    console.log(`📋 Swagger: ${helpers.getServerUrl()}/swagger`)
-  }
-  
-  console.log('💡 Mude as env vars e reinicie para ver a diferença!')
-})
+// Iniciar servidor (banner displayed by framework)
+app.listen()
 
 
 

package/app/server/live/FluxStackConfig.ts

@@ -1,6 +1,10 @@
 // 🔥 FluxStack Configuration Live Component
 
 import { LiveComponent } from '@/core/types/types'
+import { appConfig } from '@/config/app.config'
+import { serverConfig } from '@/config/server.config'
+import { loggerConfig } from '@/config/logger.config'
+import { systemConfig, systemRuntimeInfo } from '@/config/system.config'
 
 export interface FluxStackConfigState {
   // Environment Configuration
@@ -154,10 +158,10 @@ export class FluxStackConfig extends LiveComponent<FluxStackConfigState> {
     
     // Set default state with real configuration
     this.state = {
-      environment: (process.env.NODE_ENV as any) || 'development',
-      port: parseInt(process.env.PORT || '3000'),
-      host: process.env.HOST || 'localhost',
-      apiPrefix: '/api',
+      environment: appConfig.env,
+      port: serverConfig.port,
+      host: serverConfig.host,
+      apiPrefix: serverConfig.apiPrefix,
       
       framework: {
         name: 'FluxStack',
@@ -195,7 +199,7 @@ export class FluxStackConfig extends LiveComponent<FluxStackConfigState> {
         enabled: true,
         dependencies: [],
         config: {
-          level: process.env.LOG_LEVEL || 'info',
+          level: loggerConfig.level,
           format: 'pretty'
         }
       },
@@ -244,17 +248,15 @@ export class FluxStackConfig extends LiveComponent<FluxStackConfigState> {
 
   // Get runtime configuration
   private getRuntimeConfiguration() {
-    const os = require('os')
-    
     return {
-      nodeVersion: process.version,
-      bunVersion: process.versions.bun || 'N/A',
-      platform: process.platform,
-      architecture: process.arch,
-      cpuCount: os.cpus().length,
-      totalMemory: Math.round(os.totalmem() / 1024 / 1024 / 1024 * 100) / 100, // GB
-      workingDirectory: process.cwd(),
-      executablePath: process.execPath
+      nodeVersion: systemRuntimeInfo.nodeVersion,
+      bunVersion: systemRuntimeInfo.bunVersion,
+      platform: systemRuntimeInfo.platform,
+      architecture: systemRuntimeInfo.architecture,
+      cpuCount: systemRuntimeInfo.cpuCount,
+      totalMemory: systemRuntimeInfo.totalMemory,
+      workingDirectory: systemRuntimeInfo.workingDirectory,
+      executablePath: systemRuntimeInfo.executablePath
     }
   }
 
@@ -355,17 +357,17 @@ export class FluxStackConfig extends LiveComponent<FluxStackConfigState> {
   // Get Logging configuration
   private getLoggingConfiguration() {
     return {
-      level: (process.env.LOG_LEVEL as any) || 'info',
-      format: 'pretty',
+      level: loggerConfig.level as 'debug' | 'info' | 'warn' | 'error',
+      format: 'pretty' as 'json' | 'pretty' | 'compact',
       file: {
-        enabled: false,
-        path: undefined,
-        maxSize: undefined,
-        maxFiles: undefined
+        enabled: loggerConfig.logToFile,
+        path: loggerConfig.logToFile ? 'logs/app.log' : undefined,
+        maxSize: loggerConfig.maxSize,
+        maxFiles: parseInt(loggerConfig.maxFiles) || undefined
       },
       console: {
         enabled: true,
-        colors: true
+        colors: loggerConfig.enableColors
       }
     }
   }
@@ -408,16 +410,18 @@ export class FluxStackConfig extends LiveComponent<FluxStackConfigState> {
   // Update specific configuration section
   async updateConfiguration(data: { section: string; config: Record<string, any> }) {
     const { section, config } = data
-    
+
     if (!this.state[section as keyof FluxStackConfigState]) {
       throw new Error(`Invalid configuration section: ${section}`)
     }
-    
+
+    const currentSection = this.state[section as keyof FluxStackConfigState]
+    const updatedSection = typeof currentSection === 'object' && currentSection !== null
+      ? { ...currentSection as object, ...config }
+      : config
+
     this.setState({
-      [section]: {
-        ...this.state[section as keyof FluxStackConfigState],
-        ...config
-      },
+      [section]: updatedSection,
       lastUpdated: Date.now()
     } as Partial<FluxStackConfigState>)
     
@@ -433,22 +437,22 @@ export class FluxStackConfig extends LiveComponent<FluxStackConfigState> {
   // Get environment variables
   async getEnvironmentVariables() {
     const envVars = {
-      NODE_ENV: process.env.NODE_ENV,
-      PORT: process.env.PORT,
-      HOST: process.env.HOST,
-      LOG_LEVEL: process.env.LOG_LEVEL,
-      // Add other non-sensitive env vars
-      PWD: process.env.PWD,
-      PATH: process.env.PATH ? '***truncated***' : undefined,
-      USER: process.env.USER || process.env.USERNAME,
-      HOME: process.env.HOME || process.env.USERPROFILE
+      NODE_ENV: appConfig.env,
+      PORT: serverConfig.port.toString(),
+      HOST: serverConfig.host,
+      LOG_LEVEL: loggerConfig.level,
+      // Add other non-sensitive env vars from system config
+      PWD: systemConfig.pwd || undefined,
+      PATH: systemConfig.path ? '***truncated***' : undefined,
+      USER: systemConfig.currentUser,
+      HOME: systemConfig.homeDirectory || undefined
     }
-    
+
     this.emit('ENVIRONMENT_VARIABLES_REQUESTED', {
       count: Object.keys(envVars).length,
       timestamp: Date.now()
     })
-    
+
     return envVars
   }
 

package/app/server/live/SystemMonitorIntegration.ts

@@ -87,8 +87,8 @@ export class SystemMonitorIntegration {
         this.recordMessage(action, componentId, success, responseTime)
       }
     }
-    
-    console.log('🔗 SystemMonitor integration hooks setup completed')
+
+    // Setup completed - logged in auto-discovery group
   }
   
   // Record a connection event

package/app/server/live/register-components.ts

@@ -5,4 +5,4 @@
 // NOTE: If you see this in production, auto-generation worked!
 // All Live Components should be discovered and registered automatically during build
 
-console.log('🧪 Manual registration file loaded - auto-generation should handle components')
+// Removed startup log to keep output clean - auto-generation handles everything

package/app/server/middleware/errorHandling.ts

@@ -4,6 +4,7 @@
  */
 
 import type { Context } from 'elysia'
+import { appConfig } from '@/config/app.config'
 
 export interface ErrorResponse {
   error: string
@@ -139,14 +140,15 @@ export const errorHandlingMiddleware = {
     }
 
     // Default to internal server error
+    const isProduction = appConfig.env === 'production'
     return createErrorResponse(
       500,
-      process.env.NODE_ENV === 'production' 
-        ? 'Internal server error' 
+      isProduction
+        ? 'Internal server error'
         : error.message,
       'INTERNAL_ERROR',
-      process.env.NODE_ENV === 'production' 
-        ? undefined 
+      isProduction
+        ? undefined
         : { stack: error.stack },
       requestId
     )

package/app/server/routes/config.ts

@@ -0,0 +1,145 @@
+/**
+ * Config Management Routes
+ * Allows runtime configuration reload and inspection
+ */
+
+import { Elysia, t } from 'elysia'
+import { appRuntimeConfig } from '@/config/runtime.config'
+
+export const configRoutes = new Elysia({ prefix: '/config' })
+  /**
+   * Get current runtime configuration
+   */
+  .get('/', () => {
+    return {
+      success: true,
+      config: appRuntimeConfig.values,
+      timestamp: new Date().toISOString()
+    }
+  }, {
+    detail: {
+      summary: 'Get current runtime configuration',
+      tags: ['Config']
+    }
+  })
+
+  /**
+   * Reload configuration from environment
+   */
+  .post('/reload', () => {
+    try {
+      const oldConfig = { ...appRuntimeConfig.values }
+      const newConfig = appRuntimeConfig.reload()
+
+      // Find changed fields
+      const changes: Record<string, { old: any, new: any }> = {}
+      for (const key in newConfig) {
+        if (oldConfig[key] !== newConfig[key]) {
+          changes[key] = {
+            old: oldConfig[key],
+            new: newConfig[key]
+          }
+        }
+      }
+
+      return {
+        success: true,
+        message: 'Configuration reloaded successfully',
+        changes,
+        timestamp: new Date().toISOString()
+      }
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }
+    }
+  }, {
+    detail: {
+      summary: 'Reload configuration from environment variables',
+      description: 'Reloads configuration without restarting the server. Validates new values before applying.',
+      tags: ['Config']
+    }
+  })
+
+  /**
+   * Get specific config field
+   */
+  .get('/:field', ({ params: { field } }) => {
+    const value = appRuntimeConfig.get(field as any)
+
+    if (value === undefined) {
+      return {
+        success: false,
+        error: `Field '${field}' not found`,
+        timestamp: new Date().toISOString()
+      }
+    }
+
+    return {
+      success: true,
+      field,
+      value,
+      type: typeof value,
+      timestamp: new Date().toISOString()
+    }
+  }, {
+    detail: {
+      summary: 'Get specific configuration field',
+      tags: ['Config']
+    },
+    params: t.Object({
+      field: t.String()
+    })
+  })
+
+  /**
+   * Check if config field exists
+   */
+  .get('/:field/exists', ({ params: { field } }) => {
+    const exists = appRuntimeConfig.has(field as any)
+
+    return {
+      success: true,
+      field,
+      exists,
+      timestamp: new Date().toISOString()
+    }
+  }, {
+    detail: {
+      summary: 'Check if configuration field exists',
+      tags: ['Config']
+    },
+    params: t.Object({
+      field: t.String()
+    })
+  })
+
+  /**
+   * Health check for config system
+   */
+  .get('/health', () => {
+    try {
+      const config = appRuntimeConfig.values
+
+      return {
+        success: true,
+        status: 'healthy',
+        fieldsLoaded: Object.keys(config).length,
+        timestamp: new Date().toISOString()
+      }
+    } catch (error: any) {
+      return {
+        success: false,
+        status: 'unhealthy',
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }
+    }
+  }, {
+    detail: {
+      summary: 'Config system health check',
+      tags: ['Config']
+    }
+  })

package/app/server/routes/index.ts

@@ -1,6 +1,7 @@
 import { Elysia, t } from "elysia"
 import { usersRoutes } from "./users.routes"
 import { uploadRoutes } from "./upload"
+import { configRoutes } from "./config"
 
 export const apiRoutes = new Elysia({ prefix: "/api" })
   .get("/", () => ({ message: "🔥 Hot Reload funcionando! FluxStack API v1.4.0 ⚡" }), {
@@ -13,8 +14,8 @@ export const apiRoutes = new Elysia({ prefix: "/api" })
       description: 'Returns a welcome message from the FluxStack API'
     }
   })
-  .get("/health", () => ({ 
-    status: "🚀 Hot Reload ativo!", 
+  .get("/health", () => ({
+    status: "🚀 Hot Reload ativo!",
     timestamp: new Date().toISOString(),
     uptime: `${Math.floor(process.uptime())}s`,
     version: "1.4.0",
@@ -34,4 +35,5 @@ export const apiRoutes = new Elysia({ prefix: "/api" })
     }
   })
   .use(usersRoutes)
-  .use(uploadRoutes)
+  .use(uploadRoutes)
+  .use(configRoutes)

package/config/app.config.ts

@@ -0,0 +1,113 @@
+/**
+ * Application Configuration
+ * Laravel-style declarative config with validation
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+/**
+ * App configuration schema
+ */
+const appConfigSchema = {
+  // App basics
+  name: config.string('APP_NAME', 'FluxStack', true),
+
+  version: {
+    type: 'string' as const,
+    env: 'APP_VERSION',
+    default: '1.0.0',
+    validate: (value: string) => /^\d+\.\d+\.\d+$/.test(value) || 'Version must be semver format (e.g., 1.0.0)'
+  },
+
+  description: config.string('APP_DESCRIPTION', 'A FluxStack application'),
+
+  // Environment
+  env: config.enum('NODE_ENV', ['development', 'production', 'test'] as const, 'development', true),
+
+  debug: config.boolean('DEBUG', false),
+
+  // Server
+  port: {
+    type: 'number' as const,
+    env: 'PORT',
+    default: 3000,
+    required: true,
+    validate: (value: number) => {
+      if (value < 1 || value > 65535) {
+        return 'Port must be between 1 and 65535'
+      }
+      return true
+    }
+  },
+
+  host: config.string('HOST', 'localhost', true),
+
+  apiPrefix: {
+    type: 'string' as const,
+    env: 'API_PREFIX',
+    default: '/api',
+    validate: (value: string) => value.startsWith('/') || 'API prefix must start with /'
+  },
+
+  // URLs
+  url: config.string('APP_URL', undefined, false),
+
+  // Features
+  enableSwagger: config.boolean('ENABLE_SWAGGER', true),
+  enableMetrics: config.boolean('ENABLE_METRICS', false),
+  enableMonitoring: config.boolean('ENABLE_MONITORING', false),
+
+  // Client
+  clientPort: config.number('VITE_PORT', 5173),
+
+  // Logging
+  logLevel: config.enum('LOG_LEVEL', ['debug', 'info', 'warn', 'error'] as const, 'info'),
+  logFormat: config.enum('LOG_FORMAT', ['json', 'pretty'] as const, 'pretty'),
+
+  // CORS
+  corsOrigins: config.array('CORS_ORIGINS', ['*']),
+  corsMethods: config.array('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
+  corsHeaders: config.array('CORS_HEADERS', ['Content-Type', 'Authorization']),
+  corsCredentials: config.boolean('CORS_CREDENTIALS', false),
+
+  // Security
+  trustProxy: config.boolean('TRUST_PROXY', false),
+
+  sessionSecret: {
+    type: 'string' as const,
+    env: 'SESSION_SECRET',
+    default: undefined,
+    required: false,
+    validate: (value: string) => {
+      if (!value) return true // Optional
+      if (value.length < 32) {
+        return 'Session secret must be at least 32 characters'
+      }
+      return true
+    }
+  }
+} as const
+
+export const appConfig = defineConfig(appConfigSchema)
+
+// Export type for use in other files
+export type AppConfig = typeof appConfig
+
+/**
+ * Type-safe environment type
+ * Use this when you need the literal type explicitly
+ */
+export type Environment = typeof appConfig.env
+
+/**
+ * Type-safe log level type
+ */
+export type LogLevel = typeof appConfig.logLevel
+
+/**
+ * Type-safe log format type
+ */
+export type LogFormat = typeof appConfig.logFormat
+
+// Export default
+export default appConfig