create-fluxstack 1.0.0

package/core/utils/__tests__/helpers.test.ts

@@ -0,0 +1,297 @@
+/**
+ * Tests for Helper Utilities
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  formatBytes,
+  createTimer,
+  delay,
+  retry,
+  debounce,
+  throttle,
+  isProduction,
+  isDevelopment,
+  isTest,
+  deepMerge,
+  pick,
+  omit,
+  generateId,
+  safeJsonParse,
+  safeJsonStringify
+} from '../helpers'
+
+describe('Helper Utilities', () => {
+  describe('formatBytes', () => {
+    it('should format bytes correctly', () => {
+      expect(formatBytes(0)).toBe('0 Bytes')
+      expect(formatBytes(1024)).toBe('1 KB')
+      expect(formatBytes(1048576)).toBe('1 MB')
+      expect(formatBytes(1073741824)).toBe('1 GB')
+    })
+
+    it('should handle decimal places', () => {
+      expect(formatBytes(1536, 1)).toBe('1.5 KB')
+      expect(formatBytes(1536, 0)).toBe('2 KB')
+    })
+  })
+
+  describe('createTimer', () => {
+    it('should measure time correctly', async () => {
+      const timer = createTimer('test')
+      await delay(10)
+      const duration = timer.end()
+
+      // Be more lenient in CI environments where timing can be variable
+      expect(duration).toBeGreaterThanOrEqual(5)
+      expect(timer.label).toBe('test')
+    })
+  })
+
+  describe('delay', () => {
+    it('should delay execution', async () => {
+      const start = Date.now()
+      await delay(50)
+      const end = Date.now()
+
+      // Be more lenient with timing in CI environments - allow for 10ms variance
+      expect(end - start).toBeGreaterThanOrEqual(40)
+      expect(end - start).toBeLessThan(200) // Ensure it's not too long
+    })
+  })
+
+  describe('retry', () => {
+    it('should succeed on first attempt', async () => {
+      const fn = vi.fn().mockResolvedValue('success')
+      const result = await retry(fn, 3, 10)
+
+      expect(result).toBe('success')
+      expect(fn).toHaveBeenCalledTimes(1)
+    })
+
+    it('should retry on failure and eventually succeed', async () => {
+      const fn = vi.fn()
+        .mockRejectedValueOnce(new Error('fail 1'))
+        .mockRejectedValueOnce(new Error('fail 2'))
+        .mockResolvedValue('success')
+
+      const result = await retry(fn, 3, 10)
+
+      expect(result).toBe('success')
+      expect(fn).toHaveBeenCalledTimes(3)
+    })
+
+    it('should throw after max attempts', async () => {
+      const fn = vi.fn().mockRejectedValue(new Error('always fails'))
+
+      await expect(retry(fn, 2, 10)).rejects.toThrow('always fails')
+      expect(fn).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('debounce', () => {
+    beforeEach(() => {
+      vi.useFakeTimers()
+    })
+
+    afterEach(() => {
+      vi.useRealTimers()
+    })
+
+    it('should debounce function calls', () => {
+      const fn = vi.fn()
+      const debouncedFn = debounce(fn, 100)
+
+      debouncedFn('arg1')
+      debouncedFn('arg2')
+      debouncedFn('arg3')
+
+      expect(fn).not.toHaveBeenCalled()
+
+      vi.advanceTimersByTime(100)
+
+      expect(fn).toHaveBeenCalledTimes(1)
+      expect(fn).toHaveBeenCalledWith('arg3')
+    })
+  })
+
+  describe('throttle', () => {
+    beforeEach(() => {
+      vi.useFakeTimers()
+    })
+
+    afterEach(() => {
+      vi.useRealTimers()
+    })
+
+    it('should throttle function calls', () => {
+      const fn = vi.fn()
+      const throttledFn = throttle(fn, 100)
+
+      throttledFn('arg1')
+      throttledFn('arg2')
+      throttledFn('arg3')
+
+      expect(fn).toHaveBeenCalledTimes(1)
+      expect(fn).toHaveBeenCalledWith('arg1')
+
+      vi.advanceTimersByTime(100)
+
+      throttledFn('arg4')
+      expect(fn).toHaveBeenCalledTimes(2)
+      expect(fn).toHaveBeenCalledWith('arg4')
+    })
+  })
+
+  describe('Environment Checks', () => {
+    const originalEnv = process.env.NODE_ENV
+
+    afterEach(() => {
+      process.env.NODE_ENV = originalEnv
+    })
+
+    it('should detect production environment', () => {
+      process.env.NODE_ENV = 'production'
+      expect(isProduction()).toBe(true)
+      expect(isDevelopment()).toBe(false)
+      expect(isTest()).toBe(false)
+    })
+
+    it('should detect development environment', () => {
+      process.env.NODE_ENV = 'development'
+      expect(isProduction()).toBe(false)
+      expect(isDevelopment()).toBe(true)
+      expect(isTest()).toBe(false)
+    })
+
+    it('should detect test environment', () => {
+      process.env.NODE_ENV = 'test'
+      expect(isProduction()).toBe(false)
+      expect(isDevelopment()).toBe(false)
+      expect(isTest()).toBe(true)
+    })
+
+    it('should default to development when NODE_ENV is not set', () => {
+      delete process.env.NODE_ENV
+      expect(isDevelopment()).toBe(true)
+    })
+  })
+
+  describe('Object Utilities', () => {
+    describe('deepMerge', () => {
+      it('should merge objects deeply', () => {
+        const target = {
+          a: 1,
+          b: {
+            c: 2,
+            d: 3
+          }
+        }
+
+        const source = {
+          b: {
+            c: 2, // Keep existing property
+            d: 4,
+            e: 5
+          },
+          f: 6
+        }
+
+        const result = deepMerge(target, source)
+
+        expect(result).toEqual({
+          a: 1,
+          b: {
+            c: 2,
+            d: 4,
+            e: 5
+          },
+          f: 6
+        })
+      })
+
+      it('should handle arrays correctly', () => {
+        const target = { arr: [1, 2, 3] }
+        const source = { arr: [4, 5, 6] }
+
+        const result = deepMerge(target, source)
+
+        expect(result.arr).toEqual([4, 5, 6])
+      })
+    })
+
+    describe('pick', () => {
+      it('should pick specified keys', () => {
+        const obj = { a: 1, b: 2, c: 3, d: 4 }
+        const result = pick(obj, ['a', 'c'])
+
+        expect(result).toEqual({ a: 1, c: 3 })
+      })
+
+      it('should handle non-existent keys', () => {
+        const obj = { a: 1, b: 2 }
+        const result = pick(obj, ['a', 'c'] as any)
+
+        expect(result).toEqual({ a: 1 })
+      })
+    })
+
+    describe('omit', () => {
+      it('should omit specified keys', () => {
+        const obj = { a: 1, b: 2, c: 3, d: 4 }
+        const result = omit(obj, ['b', 'd'])
+
+        expect(result).toEqual({ a: 1, c: 3 })
+      })
+    })
+  })
+
+  describe('String Utilities', () => {
+    describe('generateId', () => {
+      it('should generate id with default length', () => {
+        const id = generateId()
+        expect(id).toHaveLength(8)
+        expect(id).toMatch(/^[A-Za-z0-9]+$/)
+      })
+
+      it('should generate id with custom length', () => {
+        const id = generateId(16)
+        expect(id).toHaveLength(16)
+      })
+
+      it('should generate unique ids', () => {
+        const id1 = generateId()
+        const id2 = generateId()
+        expect(id1).not.toBe(id2)
+      })
+    })
+
+    describe('safeJsonParse', () => {
+      it('should parse valid JSON', () => {
+        const result = safeJsonParse('{"a": 1}', {})
+        expect(result).toEqual({ a: 1 })
+      })
+
+      it('should return fallback for invalid JSON', () => {
+        const fallback = { error: true }
+        const result = safeJsonParse('invalid json', fallback)
+        expect(result).toBe(fallback)
+      })
+    })
+
+    describe('safeJsonStringify', () => {
+      it('should stringify valid objects', () => {
+        const result = safeJsonStringify({ a: 1 })
+        expect(result).toBe('{"a":1}')
+      })
+
+      it('should return fallback for circular references', () => {
+        const circular: any = { a: 1 }
+        circular.self = circular
+
+        const result = safeJsonStringify(circular, '{"error": true}')
+        expect(result).toBe('{"error": true}')
+      })
+    })
+  })
+})

package/core/utils/__tests__/logger.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Tests for Logger Utility
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+
+// Set test environment
+process.env.NODE_ENV = 'test'
+
+// Import the logger
+import { logger as realLogger, log as realLog } from '../logger'
+
+describe('Logger', () => {
+  let consoleSpy: {
+    debug: any
+    info: any
+    warn: any
+    error: any
+  }
+  let logger: typeof realLogger
+  let log: typeof realLog
+
+  beforeEach(() => {
+    consoleSpy = {
+      debug: vi.spyOn(console, 'debug').mockImplementation(() => {}),
+      info: vi.spyOn(console, 'info').mockImplementation(() => {}),
+      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      error: vi.spyOn(console, 'error').mockImplementation(() => {})
+    }
+    logger = realLogger
+    log = realLog
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('Log Levels', () => {
+    it('should log info messages', () => {
+      logger.info('Test info message')
+      expect(consoleSpy.info).toHaveBeenCalled()
+    })
+
+    it('should log warn messages', () => {
+      logger.warn('Test warn message')
+      expect(consoleSpy.warn).toHaveBeenCalled()
+    })
+
+    it('should log error messages', () => {
+      logger.error('Test error message')
+      expect(consoleSpy.error).toHaveBeenCalled()
+    })
+
+    it('should not log debug messages when log level is info', () => {
+      logger.debug('Test debug message')
+      expect(consoleSpy.debug).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Message Formatting', () => {
+    it('should format messages with timestamp and level', () => {
+      logger.info('Test message')
+      
+      const call = consoleSpy.info.mock.calls[0][0]
+      expect(call).toMatch(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\] INFO  Test message/)
+    })
+
+    it('should include metadata in log messages', () => {
+      const metadata = { userId: 123, action: 'login' }
+      logger.info('User action', metadata)
+      
+      const call = consoleSpy.info.mock.calls[0][0]
+      expect(call).toContain(JSON.stringify(metadata))
+    })
+  })
+
+  describe('Contextual Logging', () => {
+    it('should support contextual logging (basic test)', () => {
+      // Test that logger has basic functionality
+      expect(logger).toBeDefined()
+      expect(typeof logger.info).toBe('function')
+    })
+
+    it('should have log convenience object', () => {
+      // Test that log convenience object exists
+      expect(log).toBeDefined()
+      expect(typeof log.info).toBe('function')
+    })
+  })
+
+  describe('Performance Logging', () => {
+    it('should support basic logging functionality', () => {
+      // Test basic functionality without advanced features
+      expect(logger).toBeDefined()
+      expect(typeof logger.info).toBe('function')
+    })
+
+    it('should handle logging without errors', () => {
+      // Basic test without expecting specific console output
+      expect(() => {
+        logger.info('Test message')
+        log.info('Test message via convenience function')
+      }).not.toThrow()
+    })
+  })
+
+  describe('HTTP Request Logging', () => {
+    it('should log HTTP requests', () => {
+      logger.request('GET', '/api/users', 200, 150)
+      
+      expect(consoleSpy.info).toHaveBeenCalledWith(
+        expect.stringMatching(/GET \/api\/users 200 \(150ms\)/)
+      )
+    })
+
+    it('should log requests without status and duration', () => {
+      logger.request('POST', '/api/users')
+      
+      expect(consoleSpy.info).toHaveBeenCalledWith(
+        expect.stringMatching(/POST \/api\/users/)
+      )
+    })
+  })
+
+  describe('Convenience Functions', () => {
+    it('should provide log convenience functions', () => {
+      log.info('Test message')
+      expect(consoleSpy.info).toHaveBeenCalled()
+    })
+
+    it('should provide plugin logging', () => {
+      log.plugin('test-plugin', 'Plugin message')
+      expect(consoleSpy.debug).not.toHaveBeenCalled() // debug level, won't show with info level
+    })
+
+    it('should provide framework logging', () => {
+      log.framework('Framework message')
+      expect(consoleSpy.info).toHaveBeenCalled()
+    })
+  })
+})

package/core/utils/env-runtime-v2.ts

@@ -0,0 +1,232 @@
+/**
+ * Runtime Environment Loader V2 - Simplified API
+ * Mais elegante com casting automático e acesso direto
+ */
+
+/**
+ * Enhanced environment variable loader with smart casting
+ */
+class SmartEnvLoader {
+  private envAccessor: () => Record<string, string | undefined>
+
+  constructor() {
+    this.envAccessor = this.createDynamicAccessor()
+  }
+
+  private createDynamicAccessor(): () => Record<string, string | undefined> {
+    const globalScope = globalThis as any
+    
+    return () => {
+      // Try Bun.env first (most reliable in Bun runtime)
+      if (globalScope['Bun'] && globalScope['Bun']['env']) {
+        return globalScope['Bun']['env']
+      }
+      
+      // Fallback to process.env with dynamic access
+      if (globalScope['process'] && globalScope['process']['env']) {
+        return globalScope['process']['env']
+      }
+      
+      // Final fallback
+      const proc = eval('typeof process !== "undefined" ? process : null')
+      return proc?.env || {}
+    }
+  }
+
+  /**
+   * Smart get with automatic type conversion based on default value
+   */
+  get<T>(key: string, defaultValue?: T): T {
+    const env = this.envAccessor()
+    const value = env[key]
+    
+    if (!value || value === '') {
+      return defaultValue as T
+    }
+
+    // Auto-detect type from default value
+    if (typeof defaultValue === 'number') {
+      const parsed = parseInt(value, 10)
+      return (isNaN(parsed) ? defaultValue : parsed) as T
+    }
+
+    if (typeof defaultValue === 'boolean') {
+      return ['true', '1', 'yes', 'on'].includes(value.toLowerCase()) as T
+    }
+
+    if (Array.isArray(defaultValue)) {
+      return value.split(',').map(v => v.trim()).filter(Boolean) as T
+    }
+
+    if (typeof defaultValue === 'object' && defaultValue !== null) {
+      try {
+        return JSON.parse(value) as T
+      } catch {
+        return defaultValue
+      }
+    }
+
+    return value as T
+  }
+
+  /**
+   * Check if environment variable exists
+   */
+  has(key: string): boolean {
+    const env = this.envAccessor()
+    return key in env && env[key] !== undefined && env[key] !== ''
+  }
+
+  /**
+   * Get all environment variables
+   */
+  all(): Record<string, string> {
+    const env = this.envAccessor()
+    const result: Record<string, string> = {}
+    
+    for (const [key, value] of Object.entries(env)) {
+      if (value !== undefined && value !== '') {
+        result[key] = value
+      }
+    }
+    
+    return result
+  }
+}
+
+// Create singleton instance
+const smartEnv = new SmartEnvLoader()
+
+/**
+ * Simplified env API with smart casting
+ */
+export const env = {
+  /**
+   * Smart get - automatically casts based on default value type
+   * Usage:
+   *   env.get('PORT', 3000)           -> number
+   *   env.get('DEBUG', false)         -> boolean
+   *   env.get('ORIGINS', ['*'])       -> string[]
+   *   env.get('HOST', 'localhost')    -> string
+   */
+  get: <T>(key: string, defaultValue?: T): T => smartEnv.get(key, defaultValue),
+
+  /**
+   * Check if env var exists
+   */
+  has: (key: string) => smartEnv.has(key),
+
+  /**
+   * Get all env vars
+   */
+  all: () => smartEnv.all(),
+
+  // Common environment variables as properties with smart defaults
+  get NODE_ENV() { return this.get('NODE_ENV', 'development') },
+  get PORT() { return this.get('PORT', 3000) },
+  get HOST() { return this.get('HOST', 'localhost') },
+  get DEBUG() { return this.get('DEBUG', false) },
+  get LOG_LEVEL() { return this.get('LOG_LEVEL', 'info') },
+  get DATABASE_URL() { return this.get('DATABASE_URL', '') },
+  get JWT_SECRET() { return this.get('JWT_SECRET', '') },
+  get CORS_ORIGINS() { return this.get('CORS_ORIGINS', ['*']) },
+  get VITE_PORT() { return this.get('VITE_PORT', 5173) },
+  get API_PREFIX() { return this.get('API_PREFIX', '/api') },
+
+  // App specific
+  get FLUXSTACK_APP_NAME() { return this.get('FLUXSTACK_APP_NAME', 'FluxStack') },
+  get FLUXSTACK_APP_VERSION() { return this.get('FLUXSTACK_APP_VERSION', '1.0.0') },
+
+  // Monitoring
+  get ENABLE_MONITORING() { return this.get('ENABLE_MONITORING', false) },
+  get ENABLE_SWAGGER() { return this.get('ENABLE_SWAGGER', true) },
+  get ENABLE_METRICS() { return this.get('ENABLE_METRICS', false) },
+
+  // Database
+  get DB_HOST() { return this.get('DB_HOST', 'localhost') },
+  get DB_PORT() { return this.get('DB_PORT', 5432) },
+  get DB_NAME() { return this.get('DB_NAME', '') },
+  get DB_USER() { return this.get('DB_USER', '') },
+  get DB_PASSWORD() { return this.get('DB_PASSWORD', '') },
+  get DB_SSL() { return this.get('DB_SSL', false) },
+
+  // SMTP
+  get SMTP_HOST() { return this.get('SMTP_HOST', '') },
+  get SMTP_PORT() { return this.get('SMTP_PORT', 587) },
+  get SMTP_USER() { return this.get('SMTP_USER', '') },
+  get SMTP_PASSWORD() { return this.get('SMTP_PASSWORD', '') },
+  get SMTP_SECURE() { return this.get('SMTP_SECURE', false) }
+}
+
+/**
+ * Create namespaced environment access
+ * Usage: const db = createNamespace('DATABASE_')
+ *        db.get('URL') -> reads DATABASE_URL
+ */
+export function createNamespace(prefix: string) {
+  return {
+    get: <T>(key: string, defaultValue?: T): T => 
+      smartEnv.get(`${prefix}${key}`, defaultValue),
+    
+    has: (key: string) => smartEnv.has(`${prefix}${key}`),
+    
+    all: () => {
+      const allEnv = smartEnv.all()
+      const namespaced: Record<string, string> = {}
+      
+      for (const [key, value] of Object.entries(allEnv)) {
+        if (key.startsWith(prefix)) {
+          namespaced[key.slice(prefix.length)] = value
+        }
+      }
+      
+      return namespaced
+    }
+  }
+}
+
+/**
+ * Environment validation
+ */
+export const validate = {
+  require(keys: string[]): void {
+    const missing = keys.filter(key => !smartEnv.has(key))
+    if (missing.length > 0) {
+      throw new Error(`Missing required environment variables: ${missing.join(', ')}`)
+    }
+  },
+
+  oneOf(key: string, validValues: string[]): void {
+    const value = smartEnv.get(key, '')
+    if (value && !validValues.includes(value)) {
+      throw new Error(`${key} must be one of: ${validValues.join(', ')}, got: ${value}`)
+    }
+  }
+}
+
+/**
+ * Convenience functions
+ */
+export const helpers = {
+  isDevelopment: () => env.NODE_ENV === 'development',
+  isProduction: () => env.NODE_ENV === 'production',
+  isTest: () => env.NODE_ENV === 'test',
+  
+  getDatabaseUrl: () => {
+    const url = env.DATABASE_URL
+    if (url) return url
+    
+    const { DB_HOST, DB_PORT, DB_NAME, DB_USER, DB_PASSWORD } = env
+    if (DB_HOST && DB_NAME) {
+      const auth = DB_USER ? `${DB_USER}:${DB_PASSWORD}@` : ''
+      return `postgres://${auth}${DB_HOST}:${DB_PORT}/${DB_NAME}`
+    }
+    
+    return null
+  },
+
+  getServerUrl: () => `http://${env.HOST}:${env.PORT}`,
+  getClientUrl: () => `http://${env.HOST}:${env.VITE_PORT}`
+}
+
+export default env