create-fluxstack 1.0.1 → 1.0.2

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

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

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

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