create-fluxstack 1.0.13 → 1.0.14

package/run-env-tests.ts

@@ -1,313 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Test Runner for Environment Variable Loading System
- * Comprehensive test suite for FluxStack environment configuration
- */
-
-import { expect } from 'bun:test'
-import { 
-  EnvironmentProcessor, 
-  EnvConverter, 
-  getEnvironmentInfo,
-  ConfigMerger,
-  EnvironmentConfigApplier
-} from './core/config/env'
-import { getConfigSync } from './core/config'
-
-// ANSI color codes for output
-const colors = {
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  reset: '\x1b[0m',
-  bold: '\x1b[1m'
-}
-
-let testsPassed = 0
-let testsFailed = 0
-let testsTotal = 0
-
-function test(name: string, fn: () => void | Promise<void>) {
-  testsTotal++
-  try {
-    const result = fn()
-    if (result instanceof Promise) {
-      result.then(() => {
-        testsPassed++
-        console.log(`${colors.green}✓${colors.reset} ${name}`)
-      }).catch((error) => {
-        testsFailed++
-        console.log(`${colors.red}✗${colors.reset} ${name}`)
-        console.log(`  ${colors.red}Error: ${error.message}${colors.reset}`)
-      })
-    } else {
-      testsPassed++
-      console.log(`${colors.green}✓${colors.reset} ${name}`)
-    }
-  } catch (error) {
-    testsFailed++
-    console.log(`${colors.red}✗${colors.reset} ${name}`)
-    console.log(`  ${colors.red}Error: ${(error as Error).message}${colors.reset}`)
-  }
-}
-
-function describe(name: string, fn: () => void) {
-  console.log(`\n${colors.bold}${colors.blue}${name}${colors.reset}`)
-  fn()
-}
-
-// Save original environment
-const originalEnv = { ...process.env }
-
-function beforeEach() {
-  // Clear test environment variables
-  for (const key in process.env) {
-    if (key.startsWith('FLUXSTACK_') || key.startsWith('PORT') || key.startsWith('HOST') ||
-        key.startsWith('CORS_') || key.startsWith('LOG_') || key.startsWith('BUILD_') ||
-        key.startsWith('DATABASE_') || key.startsWith('JWT_') || key.startsWith('SMTP_') ||
-        key.startsWith('VITE_') || key.startsWith('API_') || key.startsWith('CLIENT_') ||
-        key.startsWith('MONITORING_') || key.startsWith('METRICS_') || key.startsWith('PROFILING_')) {
-      delete process.env[key]
-    }
-  }
-}
-
-function afterEach() {
-  // Restore original environment
-  process.env = { ...originalEnv }
-}
-
-// Test Suite
-console.log(`${colors.bold}FluxStack Environment Variable Loading Tests${colors.reset}\n`)
-
-describe('EnvConverter Type Conversion', () => {
-  test('converts numbers correctly', () => {
-    expect(EnvConverter.toNumber('123', 0)).toBe(123)
-    expect(EnvConverter.toNumber('invalid', 42)).toBe(42)
-    expect(EnvConverter.toNumber(undefined, 42)).toBe(42)
-  })
-
-  test('converts booleans correctly', () => {
-    expect(EnvConverter.toBoolean('true', false)).toBe(true)
-    expect(EnvConverter.toBoolean('1', false)).toBe(true)
-    expect(EnvConverter.toBoolean('false', true)).toBe(false)
-    expect(EnvConverter.toBoolean('invalid', true)).toBe(false)
-  })
-
-  test('converts arrays correctly', () => {
-    expect(EnvConverter.toArray('a,b,c')).toEqual(['a', 'b', 'c'])
-    expect(EnvConverter.toArray('a, b , c')).toEqual(['a', 'b', 'c'])
-    expect(EnvConverter.toArray('')).toEqual([])
-  })
-
-  test('converts log levels correctly', () => {
-    expect(EnvConverter.toLogLevel('debug', 'info')).toBe('debug')
-    expect(EnvConverter.toLogLevel('invalid', 'info')).toBe('info')
-  })
-})
-
-describe('EnvironmentProcessor', () => {
-  let processor: EnvironmentProcessor
-
-  beforeEach()
-  processor = new EnvironmentProcessor()
-
-  test('processes server configuration', () => {
-    process.env.PORT = '8080'
-    process.env.HOST = 'example.com'
-    process.env.FLUXSTACK_API_PREFIX = '/v1'
-
-    const config = processor.processEnvironmentVariables()
-
-    expect(config.server?.port).toBe(8080)
-    expect(config.server?.host).toBe('example.com')
-    expect(config.server?.apiPrefix).toBe('/v1')
-  })
-
-  test('processes CORS configuration', () => {
-    process.env.CORS_ORIGINS = 'http://localhost:3000,https://example.com'
-    process.env.CORS_METHODS = 'GET,POST,PUT'
-    process.env.CORS_CREDENTIALS = 'true'
-
-    const config = processor.processEnvironmentVariables()
-
-    expect(config.server?.cors?.origins).toEqual(['http://localhost:3000', 'https://example.com'])
-    expect(config.server?.cors?.methods).toEqual(['GET', 'POST', 'PUT'])
-    expect(config.server?.cors?.credentials).toBe(true)
-  })
-
-  test('processes database configuration', () => {
-    process.env.DATABASE_URL = 'postgresql://user:pass@localhost:5432/db'
-    process.env.DATABASE_SSL = 'true'
-    process.env.DATABASE_POOL_SIZE = '20'
-
-    const config = processor.processEnvironmentVariables()
-
-    expect(config.database?.url).toBe('postgresql://user:pass@localhost:5432/db')
-    expect(config.database?.ssl).toBe(true)
-    expect(config.database?.poolSize).toBe(20)
-  })
-
-  afterEach()
-})
-
-describe('Configuration Loading Integration', () => {
-  test('loads complete development configuration', () => {
-    beforeEach()
-    
-    process.env.NODE_ENV = 'development'
-    process.env.PORT = '3000'
-    process.env.HOST = 'localhost'
-    process.env.LOG_LEVEL = 'debug'
-    process.env.CORS_ORIGINS = 'http://localhost:3000,http://localhost:5173'
-
-    const config = getConfigSync()
-
-    expect(getEnvironmentInfo().isDevelopment).toBe(true)
-    expect(config.server?.port).toBe(3000)
-    expect(config.server?.host).toBe('localhost')
-    expect(config.logging?.level).toBe('debug')
-    expect(config.server?.cors?.origins).toEqual(['http://localhost:3000', 'http://localhost:5173'])
-    
-    afterEach()
-  })
-
-  test('loads complete production configuration', () => {
-    beforeEach()
-    
-    process.env.NODE_ENV = 'production'
-    process.env.PORT = '8080'
-    process.env.HOST = '0.0.0.0'
-    process.env.LOG_LEVEL = 'warn'
-    process.env.LOG_FORMAT = 'json'
-    process.env.MONITORING_ENABLED = 'true'
-    process.env.BUILD_MINIFY = 'true'
-
-    const config = getConfigSync()
-
-    expect(getEnvironmentInfo().isProduction).toBe(true)
-    expect(config.server?.port).toBe(8080)
-    expect(config.server?.host).toBe('0.0.0.0')
-    expect(config.logging?.level).toBe('warn')
-    expect(config.logging?.format).toBe('json')
-    expect(config.monitoring?.enabled).toBe(true)
-    expect(config.build?.optimization?.minify).toBe(true)
-    
-    afterEach()
-  })
-
-  test('handles precedence correctly', () => {
-    beforeEach()
-    
-    // Test precedence: FLUXSTACK_ prefix vs standard
-    process.env.PORT = '3000'
-    process.env.FLUXSTACK_PORT = '4000'
-    process.env.API_PREFIX = '/api'
-    process.env.FLUXSTACK_API_PREFIX = '/v2'
-
-    const config = getConfigSync()
-
-    // Current implementation uses || operator, so first non-empty wins
-    expect(config.server?.port).toBe(3000) // PORT wins because it's checked first
-    expect(config.server?.apiPrefix).toBe('/v2') // FLUXSTACK_API_PREFIX wins
-    
-    afterEach()
-  })
-})
-
-describe('ConfigMerger', () => {
-  test('merges configurations with precedence', () => {
-    const merger = new ConfigMerger()
-
-    const config1 = {
-      config: { server: { port: 3000, host: 'localhost' } },
-      source: 'default'
-    }
-
-    const config2 = {
-      config: { server: { port: 4000 } },
-      source: 'environment'
-    }
-
-    const result = merger.merge(config1, config2)
-
-    expect(result.server?.port).toBe(4000) // Environment overrides default
-    expect(result.server?.host).toBe('localhost') // Preserved from default
-  })
-})
-
-describe('Real-world Scenarios', () => {
-  test('Docker deployment scenario', () => {
-    beforeEach()
-    
-    process.env.NODE_ENV = 'production'
-    process.env.PORT = '8080'
-    process.env.HOST = '0.0.0.0'
-    process.env.DATABASE_URL = 'postgresql://user:pass@postgres:5432/app'
-    process.env.LOG_FORMAT = 'json'
-    process.env.MONITORING_ENABLED = 'true'
-
-    const config = getConfigSync()
-
-    expect(config.server?.port).toBe(8080)
-    expect(config.server?.host).toBe('0.0.0.0')
-    expect(config.database?.url).toBe('postgresql://user:pass@postgres:5432/app')
-    expect(config.logging?.format).toBe('json')
-    expect(config.monitoring?.enabled).toBe(true)
-    
-    afterEach()
-  })
-
-  test('handles complex nested configuration', () => {
-    beforeEach()
-    
-    process.env.CORS_ORIGINS = 'http://localhost:3000,https://myapp.com'
-    process.env.CORS_METHODS = 'GET,POST,PUT,DELETE'
-    process.env.CORS_CREDENTIALS = 'true'
-    process.env.CORS_MAX_AGE = '86400'
-
-    const config = getConfigSync()
-
-    expect(config.server?.cors?.origins).toEqual(['http://localhost:3000', 'https://myapp.com'])
-    expect(config.server?.cors?.methods).toEqual(['GET', 'POST', 'PUT', 'DELETE'])
-    expect(config.server?.cors?.credentials).toBe(true)
-    expect(config.server?.cors?.maxAge).toBe(86400)
-    
-    afterEach()
-  })
-
-  test('handles invalid environment variables gracefully', () => {
-    beforeEach()
-    
-    process.env.PORT = 'invalid'
-    process.env.LOG_LEVEL = 'invalid'
-    process.env.MONITORING_ENABLED = 'maybe'
-
-    const config = getConfigSync()
-
-    expect(typeof config.server?.port).toBe('number')
-    // Log level should be valid (invalid falls back to default)
-    expect(typeof config.logging?.level).toBe('string')
-    expect(typeof config.monitoring?.enabled).toBe('boolean')
-    
-    afterEach()
-  })
-})
-
-// Run summary
-setTimeout(() => {
-  console.log(`\n${colors.bold}Test Results:${colors.reset}`)
-  console.log(`${colors.green}✓ Passed: ${testsPassed}${colors.reset}`)
-  console.log(`${colors.red}✗ Failed: ${testsFailed}${colors.reset}`)
-  console.log(`${colors.blue}Total: ${testsTotal}${colors.reset}`)
-  
-  if (testsFailed === 0) {
-    console.log(`\n${colors.green}${colors.bold}🎉 All tests passed!${colors.reset}`)
-    process.exit(0)
-  } else {
-    console.log(`\n${colors.red}${colors.bold}❌ Some tests failed${colors.reset}`)
-    process.exit(1)
-  }
-}, 100) // Give async tests time to complete

package/tailwind.config.js

@@ -1,34 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-export default {
-  content: [
-    "./app/client/index.html",
-    "./app/client/src/**/*.{js,ts,jsx,tsx}",
-  ],
-  theme: {
-    extend: {
-      colors: {
-        // Custom colors for FluxStack branding
-        flux: {
-          50: '#f0f9ff',
-          100: '#e0f2fe',
-          200: '#bae6fd',
-          300: '#7dd3fc',
-          400: '#38bdf8',
-          500: '#0ea5e9',
-          600: '#0284c7',
-          700: '#0369a1',
-          800: '#075985',
-          900: '#0c4a6e',
-        }
-      },
-      fontFamily: {
-        sans: ['-apple-system', 'BlinkMacSystemFont', 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'sans-serif'],
-      },
-      animation: {
-        'spin-slow': 'spin 3s linear infinite',
-        'pulse-slow': 'pulse 3s cubic-bezier(0.4, 0, 0.6, 1) infinite',
-      }
-    },
-  },
-  plugins: [],
-}

package/tests/__mocks__/api.ts

@@ -1,56 +0,0 @@
-// Mock API responses for testing
-export const mockApiResponses = {
-  users: {
-    list: {
-      users: [
-        {
-          id: 1,
-          name: 'Mock User 1',
-          email: 'mock1@example.com',
-          createdAt: new Date('2024-01-01')
-        },
-        {
-          id: 2,
-          name: 'Mock User 2', 
-          email: 'mock2@example.com',
-          createdAt: new Date('2024-01-02')
-        }
-      ]
-    },
-    create: {
-      success: true,
-      user: {
-        id: 3,
-        name: 'New Mock User',
-        email: 'newmock@example.com',
-        createdAt: new Date()
-      }
-    },
-    error: {
-      success: false,
-      message: 'Mock error message'
-    }
-  },
-  api: {
-    index: {
-      message: 'Hello from Mock FluxStack API!'
-    }
-  }
-}
-
-export const mockApi = {
-  api: {
-    index: {
-      get: () => Promise.resolve({ data: mockApiResponses.api.index })
-    },
-    users: {
-      get: () => Promise.resolve({ data: mockApiResponses.users.list }),
-      post: (body: any) => {
-        if (body.email === 'error@test.com') {
-          return Promise.resolve({ data: mockApiResponses.users.error })
-        }
-        return Promise.resolve({ data: mockApiResponses.users.create })
-      }
-    }
-  }
-}

package/tests/fixtures/users.ts

@@ -1,69 +0,0 @@
-import type { User, CreateUserRequest } from '@/app/shared/types'
-
-export const mockUsers: User[] = [
-  {
-    id: 1,
-    name: 'João Silva',
-    email: 'joao@example.com',
-    createdAt: new Date('2024-01-01T10:00:00Z')
-  },
-  {
-    id: 2,
-    name: 'Maria Santos',
-    email: 'maria@example.com',
-    createdAt: new Date('2024-01-02T11:00:00Z')
-  },
-  {
-    id: 3,
-    name: 'Pedro Costa',
-    email: 'pedro@example.com',
-    createdAt: new Date('2024-01-03T12:00:00Z')
-  }
-]
-
-export const validUserRequests: CreateUserRequest[] = [
-  {
-    name: 'Ana Lima',
-    email: 'ana@example.com'
-  },
-  {
-    name: 'Carlos Oliveira',
-    email: 'carlos@example.com'
-  },
-  {
-    name: 'Teste User',
-    email: 'teste@example.com'
-  }
-]
-
-export const invalidUserRequests = [
-  {
-    name: 'A', // Too short
-    email: 'valid@example.com'
-  },
-  {
-    name: 'Valid Name',
-    email: 'invalid-email' // Invalid format
-  },
-  {
-    name: '', // Empty name
-    email: 'empty@example.com'
-  },
-  {
-    name: 'Valid Name',
-    email: '' // Empty email
-  },
-  {
-    name: 'Valid Name'
-    // Missing email
-  },
-  {
-    email: 'missing@example.com'
-    // Missing name
-  }
-]
-
-export const duplicateEmailRequest: CreateUserRequest = {
-  name: 'Duplicate User',
-  email: 'joao@example.com' // Same as first mock user
-}

package/tests/integration/api/users.routes.test.ts

@@ -1,221 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { Elysia } from 'elysia'
-import { usersRoutes } from '@/app/server/routes/users.routes'
-
-describe('Users API Routes', () => {
-  let app: Elysia
-
-  beforeEach(() => {
-    // Create a fresh Elysia app for each test
-    app = new Elysia().use(usersRoutes)
-  })
-
-  describe('GET /users', () => {
-    it('should return users list', async () => {
-      const response = await app
-        .handle(new Request('http://localhost/users'))
-        
-      expect(response.status).toBe(200)
-      
-      const data = await response.json()
-      expect(data).toBeDefined()
-      expect(data.users).toBeDefined()
-      expect(Array.isArray(data.users)).toBe(true)
-    })
-
-    it('should return users with correct structure', async () => {
-      const response = await app
-        .handle(new Request('http://localhost/users'))
-        
-      const data = await response.json()
-      
-      if (data.users.length > 0) {
-        const user = data.users[0]
-        expect(user).toHaveProperty('id')
-        expect(user).toHaveProperty('name')
-        expect(user).toHaveProperty('email')
-        expect(user).toHaveProperty('createdAt')
-      }
-    })
-  })
-
-  describe('GET /users/:id', () => {
-    it('should return user by ID', async () => {
-      // First get all users to find a valid ID
-      const usersResponse = await app
-        .handle(new Request('http://localhost/users'))
-      const usersData = await usersResponse.json()
-      
-      if (usersData.users.length > 0) {
-        const userId = usersData.users[0].id
-        
-        const response = await app
-          .handle(new Request(`http://localhost/users/${userId}`))
-          
-        expect(response.status).toBe(200)
-        
-        const data = await response.json()
-        expect(data.user).toBeDefined()
-        expect(data.user.id).toBe(userId)
-      }
-    })
-
-    it('should return error for non-existent user', async () => {
-      const response = await app
-        .handle(new Request('http://localhost/users/99999'))
-        
-      expect(response.status).toBe(200) // Elysia returns 200 by default
-      
-      // Check if response has content before parsing JSON
-      const text = await response.text()
-      if (text) {
-        const data = JSON.parse(text)
-        expect(data.error).toBe('Usuário não encontrado')
-      } else {
-        // If no response body, the test still passes as the behavior is expected
-        expect(response.status).toBe(200)
-      }
-    })
-
-    it('should validate ID parameter', async () => {
-      const response = await app
-        .handle(new Request('http://localhost/users/invalid-id'))
-        
-      // Should handle invalid ID gracefully
-      expect(response.status).toBeGreaterThanOrEqual(200)
-    })
-  })
-
-  describe('POST /users', () => {
-    it('should create new user with valid data', async () => {
-      const userData = {
-        name: 'Integration Test User',
-        email: 'integration@test.com'
-      }
-
-      const response = await app
-        .handle(new Request('http://localhost/users', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(userData)
-        }))
-        
-      expect(response.status).toBe(200)
-      
-      const data = await response.json()
-      expect(data.success).toBe(true)
-      expect(data.user).toBeDefined()
-      expect(data.user.name).toBe(userData.name)
-      expect(data.user.email).toBe(userData.email)
-      expect(data.user.id).toBeDefined()
-    })
-
-    it('should reject user with invalid data', async () => {
-      const invalidData = {
-        name: 'A', // Too short
-        email: 'invalid-email' // Invalid format
-      }
-
-      const response = await app
-        .handle(new Request('http://localhost/users', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(invalidData)
-        }))
-        
-      expect(response.status).toBe(400)
-      
-      const data = await response.json()
-      expect(data.success).toBe(false)
-      expect(data.error).toBeDefined()
-    })
-
-    it('should reject user with missing fields', async () => {
-      const incompleteData = {
-        name: 'Test User'
-        // Missing email
-      }
-
-      const response = await app
-        .handle(new Request('http://localhost/users', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(incompleteData)
-        }))
-        
-      expect(response.status).toBe(400)
-    })
-
-    it('should prevent duplicate emails', async () => {
-      const userData = {
-        name: 'Duplicate Test User',
-        email: 'duplicate@integration.test'
-      }
-
-      // Create first user
-      const firstResponse = await app
-        .handle(new Request('http://localhost/users', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(userData)
-        }))
-        
-      expect(firstResponse.status).toBe(200)
-
-      // Try to create user with same email
-      const secondResponse = await app
-        .handle(new Request('http://localhost/users', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(userData)
-        }))
-        
-      const data = await secondResponse.json()
-      expect(data.success).toBe(false)
-      expect(data.message).toBe('Email já está em uso')
-    })
-  })
-
-  describe('DELETE /users/:id', () => {
-    it('should delete existing user', async () => {
-      // First create a user to delete
-      const userData = {
-        name: 'User to Delete',
-        email: 'delete@test.com'
-      }
-
-      const createResponse = await app
-        .handle(new Request('http://localhost/users', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(userData)
-        }))
-
-      const createData = await createResponse.json()
-      const userId = createData.user.id
-
-      // Now delete the user
-      const deleteResponse = await app
-        .handle(new Request(`http://localhost/users/${userId}`, {
-          method: 'DELETE'
-        }))
-        
-      expect(deleteResponse.status).toBe(200)
-      
-      const deleteData = await deleteResponse.json()
-      expect(deleteData.success).toBe(true)
-      expect(deleteData.message).toBe('Usuário deletado com sucesso')
-    })
-
-    it('should return error when deleting non-existent user', async () => {
-      const response = await app
-        .handle(new Request('http://localhost/users/99999', {
-          method: 'DELETE'
-        }))
-        
-      const data = await response.json()
-      expect(data.success).toBe(false)
-      expect(data.message).toBe('Usuário não encontrado')
-    })
-  })
-})