create-fluxstack 1.0.1 → 1.0.3

package/meu-app-teste/core/config/__tests__/validator.test.ts

@@ -0,0 +1,318 @@
+/**
+ * Tests for Configuration Validator
+ */
+
+import { describe, it, expect } from 'vitest'
+import { 
+  validateConfig, 
+  validateConfigStrict,
+  createEnvironmentValidator,
+  validatePartialConfig,
+  getConfigSuggestions
+} from '../validator'
+import { defaultFluxStackConfig } from '../schema'
+import type { FluxStackConfig } from '../schema'
+
+describe('Configuration Validator', () => {
+  describe('validateConfig', () => {
+    it('should validate default configuration successfully', () => {
+      const result = validateConfig(defaultFluxStackConfig)
+      
+      expect(result.valid).toBe(true)
+      expect(result.errors).toHaveLength(0)
+    })
+
+    it('should detect missing required properties', () => {
+      const invalidConfig = {
+        app: { name: 'test' }, // missing version
+        server: defaultFluxStackConfig.server,
+        client: defaultFluxStackConfig.client,
+        build: defaultFluxStackConfig.build,
+        plugins: defaultFluxStackConfig.plugins,
+        logging: defaultFluxStackConfig.logging,
+        monitoring: defaultFluxStackConfig.monitoring
+      } as FluxStackConfig
+
+      const result = validateConfig(invalidConfig)
+      
+      expect(result.valid).toBe(false)
+      expect(result.errors.some(e => e.includes('version'))).toBe(true)
+    })
+
+    it('should detect invalid port numbers', () => {
+      const invalidConfig = {
+        ...defaultFluxStackConfig,
+        server: {
+          ...defaultFluxStackConfig.server,
+          port: 70000 // Invalid port
+        }
+      }
+
+      const result = validateConfig(invalidConfig)
+      
+      expect(result.valid).toBe(false)
+      expect(result.errors.some(e => e.includes('port'))).toBe(true)
+    })
+
+    it('should detect port conflicts', () => {
+      const conflictConfig = {
+        ...defaultFluxStackConfig,
+        server: { ...defaultFluxStackConfig.server, port: 3000 },
+        client: { ...defaultFluxStackConfig.client, port: 3000 }
+      }
+
+      const result = validateConfig(conflictConfig)
+      
+      expect(result.valid).toBe(false)
+      expect(result.errors.some(e => e.includes('different'))).toBe(true)
+    })
+
+    it('should warn about security issues', () => {
+      const insecureConfig = {
+        ...defaultFluxStackConfig,
+        server: {
+          ...defaultFluxStackConfig.server,
+          cors: {
+            ...defaultFluxStackConfig.server.cors,
+            origins: ['*'],
+            credentials: true
+          }
+        }
+      }
+
+      // Mock production environment
+      const originalEnv = process.env.NODE_ENV
+      process.env.NODE_ENV = 'production'
+
+      const result = validateConfig(insecureConfig)
+      
+      expect(result.warnings.some(w => w.includes('wildcard'))).toBe(true)
+
+      // Restore environment
+      process.env.NODE_ENV = originalEnv
+    })
+
+    it('should validate enum values', () => {
+      const invalidConfig = {
+        ...defaultFluxStackConfig,
+        logging: {
+          ...defaultFluxStackConfig.logging,
+          level: 'invalid' as any
+        }
+      }
+
+      const result = validateConfig(invalidConfig)
+      
+      expect(result.valid).toBe(false)
+      expect(result.errors.some(e => e.includes('one of'))).toBe(true)
+    })
+
+    it('should validate array constraints', () => {
+      const invalidConfig = {
+        ...defaultFluxStackConfig,
+        server: {
+          ...defaultFluxStackConfig.server,
+          cors: {
+            ...defaultFluxStackConfig.server.cors,
+            origins: [] // Empty array
+          }
+        }
+      }
+
+      const result = validateConfig(invalidConfig)
+      
+      expect(result.valid).toBe(false)
+      expect(result.errors.some(e => e.includes('at least'))).toBe(true)
+    })
+  })
+
+  describe('validateConfigStrict', () => {
+    it('should not throw for valid configuration', () => {
+      expect(() => {
+        validateConfigStrict(defaultFluxStackConfig)
+      }).not.toThrow()
+    })
+
+    it('should throw for invalid configuration', () => {
+      const invalidConfig = {
+        ...defaultFluxStackConfig,
+        app: { name: '' } // Invalid empty name
+      } as FluxStackConfig
+
+      expect(() => {
+        validateConfigStrict(invalidConfig)
+      }).toThrow()
+    })
+  })
+
+  describe('createEnvironmentValidator', () => {
+    it('should create production validator with additional checks', () => {
+      const prodValidator = createEnvironmentValidator('production')
+      
+      const devConfig = {
+        ...defaultFluxStackConfig,
+        logging: { ...defaultFluxStackConfig.logging, level: 'debug' as const }
+      }
+
+      const result = prodValidator(devConfig)
+      
+      expect(result.warnings.some(w => w.includes('Debug logging'))).toBe(true)
+    })
+
+    it('should create development validator with build warnings', () => {
+      const devValidator = createEnvironmentValidator('development')
+      
+      const prodConfig = {
+        ...defaultFluxStackConfig,
+        build: {
+          ...defaultFluxStackConfig.build,
+          optimization: {
+            ...defaultFluxStackConfig.build.optimization,
+            minify: true
+          }
+        }
+      }
+
+      const result = devValidator(prodConfig)
+      
+      expect(result.warnings.some(w => w.includes('Minification enabled'))).toBe(true)
+    })
+  })
+
+  describe('validatePartialConfig', () => {
+    it('should validate partial configuration against base', () => {
+      const partialConfig = {
+        server: {
+          port: 4000,
+          host: 'localhost',
+          apiPrefix: '/api',
+          cors: {
+            origins: ['*'],
+            methods: ['GET', 'POST'],
+            headers: ['Content-Type'],
+            credentials: false,
+            maxAge: 86400
+          },
+          middleware: []
+        }
+      }
+
+      const result = validatePartialConfig(partialConfig, defaultFluxStackConfig)
+      
+      expect(result.valid).toBe(true)
+    })
+
+    it('should detect conflicts in partial configuration', () => {
+      const partialConfig = {
+        server: {
+          port: 70000, // Invalid port
+          host: 'localhost',
+          apiPrefix: '/api',
+          cors: {
+            origins: ['*'],
+            methods: ['GET', 'POST'],
+            headers: ['Content-Type'],
+            credentials: false,
+            maxAge: 86400
+          },
+          middleware: []
+        }
+      }
+
+      const result = validatePartialConfig(partialConfig, defaultFluxStackConfig)
+      
+      expect(result.valid).toBe(false)
+    })
+  })
+
+  describe('getConfigSuggestions', () => {
+    it('should provide suggestions for improvement', () => {
+      const basicConfig = {
+        ...defaultFluxStackConfig,
+        monitoring: { ...defaultFluxStackConfig.monitoring, enabled: false }
+      }
+
+      const suggestions = getConfigSuggestions(basicConfig)
+      
+      expect(suggestions.some(s => s.includes('monitoring'))).toBe(true)
+    })
+
+    it('should suggest database configuration', () => {
+      const configWithoutDb = {
+        ...defaultFluxStackConfig,
+        database: undefined
+      }
+
+      const suggestions = getConfigSuggestions(configWithoutDb)
+      
+      expect(suggestions.some(s => s.includes('database'))).toBe(true)
+    })
+
+    it('should suggest plugin enablement', () => {
+      const configWithoutPlugins = {
+        ...defaultFluxStackConfig,
+        plugins: { ...defaultFluxStackConfig.plugins, enabled: [] }
+      }
+
+      const suggestions = getConfigSuggestions(configWithoutPlugins)
+      
+      expect(suggestions.some(s => s.includes('plugins'))).toBe(true)
+    })
+  })
+
+  describe('Business Logic Validation', () => {
+    it('should validate plugin conflicts', () => {
+      const conflictConfig = {
+        ...defaultFluxStackConfig,
+        plugins: {
+          enabled: ['logger', 'cors'],
+          disabled: ['logger'], // Conflict: logger is both enabled and disabled
+          config: {}
+        }
+      }
+
+      const result = validateConfig(conflictConfig)
+      
+      expect(result.warnings.some(w => w.includes('both enabled and disabled'))).toBe(true)
+    })
+
+    it('should validate authentication security', () => {
+      const weakAuthConfig = {
+        ...defaultFluxStackConfig,
+        auth: {
+          secret: 'short', // Too short
+          expiresIn: '24h'
+        }
+      }
+
+      const result = validateConfig(weakAuthConfig)
+      
+      expect(result.warnings.some(w => w.includes('too short'))).toBe(true)
+    })
+
+    it('should validate build optimization settings', () => {
+      // Mock production environment
+      const originalEnv = process.env.NODE_ENV
+      process.env.NODE_ENV = 'production'
+
+      const unoptimizedConfig = {
+        ...defaultFluxStackConfig,
+        build: {
+          ...defaultFluxStackConfig.build,
+          optimization: {
+            ...defaultFluxStackConfig.build.optimization,
+            minify: false,
+            treeshake: false
+          }
+        }
+      }
+
+      const result = validateConfig(unoptimizedConfig)
+      
+      expect(result.warnings.some(w => w.includes('minification') || w.includes('tree-shaking'))).toBe(true)
+
+      // Restore environment
+      process.env.NODE_ENV = originalEnv
+    })
+  })
+})

package/meu-app-teste/core/config/env-dynamic.ts

@@ -0,0 +1,326 @@
+/**
+ * Dynamic Environment Configuration Adapter for FluxStack
+ * Integrates runtime env loader with existing configuration system
+ * Solves Bun build issue by using dynamic environment access
+ */
+
+import { env, runtimeEnv, envValidation } from '../utils/env-runtime'
+import type { FluxStackConfig, LogLevel, BuildTarget, LogFormat } from './schema'
+
+/**
+ * Enhanced Environment Processor that uses dynamic env access
+ * Replaces the original EnvironmentProcessor from env.ts
+ */
+export class DynamicEnvironmentProcessor {
+  private precedenceMap: Map<string, any> = new Map()
+
+  /**
+   * Process environment variables using dynamic runtime access
+   * This prevents Bun from fixing env values during build
+   */
+  processEnvironmentVariables(): Partial<FluxStackConfig> {
+    const config: any = {}
+
+    // App configuration
+    this.setConfigValue(config, 'app.name', 
+      env.get('FLUXSTACK_APP_NAME') || env.get('APP_NAME'), 'string')
+    this.setConfigValue(config, 'app.version',
+      env.get('FLUXSTACK_APP_VERSION') || env.get('APP_VERSION'), 'string')
+    this.setConfigValue(config, 'app.description',
+      env.get('FLUXSTACK_APP_DESCRIPTION') || env.get('APP_DESCRIPTION'), 'string')
+
+    // Server configuration
+    this.setConfigValue(config, 'server.port',
+      env.get('PORT') || env.get('FLUXSTACK_PORT'), 'number')
+    this.setConfigValue(config, 'server.host',
+      env.get('HOST') || env.get('FLUXSTACK_HOST'), 'string')
+    this.setConfigValue(config, 'server.apiPrefix',
+      env.get('FLUXSTACK_API_PREFIX') || env.get('API_PREFIX'), 'string')
+
+    // CORS configuration
+    this.setConfigValue(config, 'server.cors.origins',
+      env.get('CORS_ORIGINS') || env.get('FLUXSTACK_CORS_ORIGINS'), 'array')
+    this.setConfigValue(config, 'server.cors.methods',
+      env.get('CORS_METHODS') || env.get('FLUXSTACK_CORS_METHODS'), 'array')
+    this.setConfigValue(config, 'server.cors.headers',
+      env.get('CORS_HEADERS') || env.get('FLUXSTACK_CORS_HEADERS'), 'array')
+    this.setConfigValue(config, 'server.cors.credentials',
+      env.get('CORS_CREDENTIALS') || env.get('FLUXSTACK_CORS_CREDENTIALS'), 'boolean')
+    this.setConfigValue(config, 'server.cors.maxAge',
+      env.get('CORS_MAX_AGE') || env.get('FLUXSTACK_CORS_MAX_AGE'), 'number')
+
+    // Client configuration
+    this.setConfigValue(config, 'client.port',
+      env.get('VITE_PORT') || env.get('CLIENT_PORT') || env.get('FLUXSTACK_CLIENT_PORT'), 'number')
+    this.setConfigValue(config, 'client.proxy.target',
+      env.get('VITE_API_URL') || env.get('API_URL') || env.get('FLUXSTACK_PROXY_TARGET'), 'string')
+    this.setConfigValue(config, 'client.build.sourceMaps',
+      env.get('FLUXSTACK_CLIENT_SOURCEMAPS'), 'boolean')
+    this.setConfigValue(config, 'client.build.minify',
+      env.get('FLUXSTACK_CLIENT_MINIFY'), 'boolean')
+
+    // Build configuration
+    this.setConfigValue(config, 'build.target',
+      env.get('BUILD_TARGET') || env.get('FLUXSTACK_BUILD_TARGET'), 'buildTarget')
+    this.setConfigValue(config, 'build.outDir',
+      env.get('BUILD_OUTDIR') || env.get('FLUXSTACK_BUILD_OUTDIR'), 'string')
+    this.setConfigValue(config, 'build.sourceMaps',
+      env.get('BUILD_SOURCEMAPS') || env.get('FLUXSTACK_BUILD_SOURCEMAPS'), 'boolean')
+    this.setConfigValue(config, 'build.clean',
+      env.get('BUILD_CLEAN') || env.get('FLUXSTACK_BUILD_CLEAN'), 'boolean')
+
+    // Build optimization
+    this.setConfigValue(config, 'build.optimization.minify',
+      env.get('BUILD_MINIFY') || env.get('FLUXSTACK_BUILD_MINIFY'), 'boolean')
+    this.setConfigValue(config, 'build.optimization.treeshake',
+      env.get('BUILD_TREESHAKE') || env.get('FLUXSTACK_BUILD_TREESHAKE'), 'boolean')
+    this.setConfigValue(config, 'build.optimization.compress',
+      env.get('BUILD_COMPRESS') || env.get('FLUXSTACK_BUILD_COMPRESS'), 'boolean')
+    this.setConfigValue(config, 'build.optimization.splitChunks',
+      env.get('BUILD_SPLIT_CHUNKS') || env.get('FLUXSTACK_BUILD_SPLIT_CHUNKS'), 'boolean')
+    this.setConfigValue(config, 'build.optimization.bundleAnalyzer',
+      env.get('BUILD_ANALYZER') || env.get('FLUXSTACK_BUILD_ANALYZER'), 'boolean')
+
+    // Logging configuration
+    this.setConfigValue(config, 'logging.level',
+      env.get('LOG_LEVEL') || env.get('FLUXSTACK_LOG_LEVEL'), 'logLevel')
+    this.setConfigValue(config, 'logging.format',
+      env.get('LOG_FORMAT') || env.get('FLUXSTACK_LOG_FORMAT'), 'logFormat')
+
+    // Monitoring configuration
+    this.setConfigValue(config, 'monitoring.enabled',
+      env.get('MONITORING_ENABLED') || env.get('FLUXSTACK_MONITORING_ENABLED'), 'boolean')
+    this.setConfigValue(config, 'monitoring.metrics.enabled',
+      env.get('METRICS_ENABLED') || env.get('FLUXSTACK_METRICS_ENABLED'), 'boolean')
+    this.setConfigValue(config, 'monitoring.metrics.collectInterval',
+      env.get('METRICS_INTERVAL') || env.get('FLUXSTACK_METRICS_INTERVAL'), 'number')
+    this.setConfigValue(config, 'monitoring.profiling.enabled',
+      env.get('PROFILING_ENABLED') || env.get('FLUXSTACK_PROFILING_ENABLED'), 'boolean')
+    this.setConfigValue(config, 'monitoring.profiling.sampleRate',
+      env.get('PROFILING_SAMPLE_RATE') || env.get('FLUXSTACK_PROFILING_SAMPLE_RATE'), 'number')
+
+    // Database configuration
+    this.setConfigValue(config, 'database.url', env.get('DATABASE_URL'), 'string')
+    this.setConfigValue(config, 'database.host', env.get('DATABASE_HOST'), 'string')
+    this.setConfigValue(config, 'database.port', env.get('DATABASE_PORT'), 'number')
+    this.setConfigValue(config, 'database.database', env.get('DATABASE_NAME'), 'string')
+    this.setConfigValue(config, 'database.user', env.get('DATABASE_USER'), 'string')
+    this.setConfigValue(config, 'database.password', env.get('DATABASE_PASSWORD'), 'string')
+    this.setConfigValue(config, 'database.ssl', env.get('DATABASE_SSL'), 'boolean')
+    this.setConfigValue(config, 'database.poolSize', env.get('DATABASE_POOL_SIZE'), 'number')
+
+    // Auth configuration
+    this.setConfigValue(config, 'auth.secret', env.get('JWT_SECRET'), 'string')
+    this.setConfigValue(config, 'auth.expiresIn', env.get('JWT_EXPIRES_IN'), 'string')
+    this.setConfigValue(config, 'auth.algorithm', env.get('JWT_ALGORITHM'), 'string')
+    this.setConfigValue(config, 'auth.issuer', env.get('JWT_ISSUER'), 'string')
+
+    // Email configuration
+    this.setConfigValue(config, 'email.host', env.get('SMTP_HOST'), 'string')
+    this.setConfigValue(config, 'email.port', env.get('SMTP_PORT'), 'number')
+    this.setConfigValue(config, 'email.user', env.get('SMTP_USER'), 'string')
+    this.setConfigValue(config, 'email.password', env.get('SMTP_PASSWORD'), 'string')
+    this.setConfigValue(config, 'email.secure', env.get('SMTP_SECURE'), 'boolean')
+    this.setConfigValue(config, 'email.from', env.get('SMTP_FROM'), 'string')
+
+    // Storage configuration
+    this.setConfigValue(config, 'storage.uploadPath', env.get('UPLOAD_PATH'), 'string')
+    this.setConfigValue(config, 'storage.maxFileSize', env.get('MAX_FILE_SIZE'), 'number')
+    this.setConfigValue(config, 'storage.provider', env.get('STORAGE_PROVIDER'), 'string')
+
+    // Plugin configuration
+    this.setConfigValue(config, 'plugins.enabled',
+      env.get('FLUXSTACK_PLUGINS_ENABLED'), 'array')
+    this.setConfigValue(config, 'plugins.disabled',
+      env.get('FLUXSTACK_PLUGINS_DISABLED'), 'array')
+
+    return this.cleanEmptyObjects(config)
+  }
+
+  private setConfigValue(
+    config: any,
+    path: string,
+    value: string | undefined,
+    type: string
+  ): void {
+    if (value === undefined || value === '') return
+
+    const convertedValue = this.convertValue(value, type)
+    if (convertedValue !== undefined) {
+      this.setNestedProperty(config, path, convertedValue)
+
+      // Track precedence
+      this.precedenceMap.set(path, {
+        source: 'environment',
+        path,
+        value: convertedValue,
+        priority: 3
+      })
+    }
+  }
+
+  private convertValue(value: string, type: string): any {
+    switch (type) {
+      case 'string':
+        return value
+      case 'number':
+        const num = parseInt(value, 10)
+        return isNaN(num) ? undefined : num
+      case 'boolean':
+        return ['true', '1', 'yes', 'on'].includes(value.toLowerCase())
+      case 'array':
+        return value.split(',').map(v => v.trim()).filter(Boolean)
+      case 'logLevel':
+        const level = value.toLowerCase() as LogLevel
+        return ['debug', 'info', 'warn', 'error'].includes(level) ? level : 'info'
+      case 'buildTarget':
+        const target = value.toLowerCase() as BuildTarget
+        return ['bun', 'node', 'docker'].includes(target) ? target : 'bun'
+      case 'logFormat':
+        const format = value.toLowerCase() as LogFormat
+        return ['json', 'pretty'].includes(format) ? format : 'pretty'
+      case 'object':
+        try {
+          return JSON.parse(value)
+        } catch {
+          return {}
+        }
+      default:
+        return value
+    }
+  }
+
+  private setNestedProperty(obj: any, path: string, value: any): void {
+    const keys = path.split('.')
+    let current = obj
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i]
+      if (!(key in current) || typeof current[key] !== 'object') {
+        current[key] = {}
+      }
+      current = current[key]
+    }
+
+    current[keys[keys.length - 1]] = value
+  }
+
+  private cleanEmptyObjects(obj: any): any {
+    if (typeof obj !== 'object' || obj === null) return obj
+
+    const cleaned: any = {}
+
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        const cleanedValue = this.cleanEmptyObjects(value)
+        if (Object.keys(cleanedValue).length > 0) {
+          cleaned[key] = cleanedValue
+        }
+      } else if (value !== undefined && value !== null) {
+        cleaned[key] = value
+      }
+    }
+
+    return cleaned
+  }
+
+  getPrecedenceInfo(): Map<string, any> {
+    return new Map(this.precedenceMap)
+  }
+
+  clearPrecedence(): void {
+    this.precedenceMap.clear()
+  }
+}
+
+/**
+ * Enhanced environment info with dynamic access
+ */
+export function getDynamicEnvironmentInfo() {
+  const nodeEnv = env.get('NODE_ENV', 'development')
+
+  return {
+    name: nodeEnv,
+    isDevelopment: nodeEnv === 'development',
+    isProduction: nodeEnv === 'production',
+    isTest: nodeEnv === 'test',
+    nodeEnv
+  }
+}
+
+/**
+ * Runtime configuration loader that uses dynamic env access
+ */
+export function loadConfigFromDynamicEnv(): Partial<FluxStackConfig> {
+  const processor = new DynamicEnvironmentProcessor()
+  return processor.processEnvironmentVariables()
+}
+
+/**
+ * Utility functions for backward compatibility
+ */
+export function isDevelopment(): boolean {
+  return getDynamicEnvironmentInfo().isDevelopment
+}
+
+export function isProduction(): boolean {
+  return getDynamicEnvironmentInfo().isProduction
+}
+
+export function isTest(): boolean {
+  return getDynamicEnvironmentInfo().isTest
+}
+
+/**
+ * Validate critical environment variables for production
+ */
+export function validateProductionEnv(): void {
+  if (isProduction()) {
+    const requiredVars = ['NODE_ENV']
+    const missingVars = requiredVars.filter(key => !env.has(key))
+    
+    if (missingVars.length > 0) {
+      throw new Error(`Missing required production environment variables: ${missingVars.join(', ')}`)
+    }
+
+    // Validate LOG_LEVEL for production
+    const logLevel = env.get('LOG_LEVEL')
+    if (logLevel === 'debug') {
+      console.warn('⚠️  Production environment should not use debug logging')
+    }
+  }
+}
+
+/**
+ * Create environment-aware configuration
+ */
+export function createDynamicConfig(): Partial<FluxStackConfig> {
+  const envInfo = getDynamicEnvironmentInfo()
+  const envConfig = loadConfigFromDynamicEnv()
+
+  // Add environment-specific defaults
+  const config: any = { ...envConfig }
+
+  // Ensure proper defaults based on environment
+  if (envInfo.isDevelopment) {
+    config.logging = {
+      level: env.get('LOG_LEVEL', 'debug'),
+      format: env.get('LOG_FORMAT', 'pretty'),
+      ...config.logging
+    }
+  } else if (envInfo.isProduction) {
+    config.logging = {
+      level: env.get('LOG_LEVEL', 'warn'),
+      format: env.get('LOG_FORMAT', 'json'),
+      ...config.logging
+    }
+  }
+
+  return config
+}
+
+// Export singleton instance
+export const dynamicEnvironmentProcessor = new DynamicEnvironmentProcessor()
+
+// Export runtime environment access
+export { env, runtimeEnv, envValidation } from '../utils/env-runtime'