create-fluxstack 1.0.1 → 1.0.2

package/core/config/__tests__/loader.test.ts

@@ -1,331 +0,0 @@
-/**
- * Tests for Configuration Loader
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { 
-  loadConfig, 
-  loadConfigSync,
-  getConfigValue,
-  hasConfigValue,
-  createConfigSubset
-} from '../loader'
-import { defaultFluxStackConfig } from '../schema'
-import { writeFileSync, unlinkSync, existsSync } from 'fs'
-import { join } from 'path'
-
-describe('Configuration Loader', () => {
-  const testConfigPath = join(process.cwd(), 'test.config.ts')
-  const originalEnv = { ...process.env }
-
-  beforeEach(() => {
-    // Clean up environment
-    Object.keys(process.env).forEach(key => {
-      if (key.startsWith('FLUXSTACK_') || key.startsWith('TEST_') || 
-          ['PORT', 'HOST', 'LOG_LEVEL', 'CORS_ORIGINS', 'CORS_METHODS', 'CORS_HEADERS', 
-           'CORS_CREDENTIALS', 'MONITORING_ENABLED', 'VITE_PORT'].includes(key)) {
-        delete process.env[key]
-      }
-    })
-  })
-
-  afterEach(() => {
-    // Restore original environment
-    process.env = { ...originalEnv }
-    
-    // Clean up test files
-    if (existsSync(testConfigPath)) {
-      unlinkSync(testConfigPath)
-    }
-  })
-
-  describe('loadConfigSync', () => {
-    it('should load default configuration', () => {
-      const result = loadConfigSync({ environment: 'development' })
-      
-      expect(result.config).toBeDefined()
-      expect(result.sources).toContain('defaults')
-      expect(result.errors).toHaveLength(0)
-    })
-
-    it('should load environment variables', () => {
-      process.env.PORT = '4000'
-      process.env.FLUXSTACK_APP_NAME = 'test-app'
-      process.env.LOG_LEVEL = 'debug'
-
-      const result = loadConfigSync({ environment: 'development' })
-      
-      expect(result.config.server.port).toBe(4000)
-      expect(result.config.app.name).toBe('test-app')
-      expect(result.config.logging.level).toBe('debug')
-      expect(result.sources).toContain('environment')
-    })
-
-    it('should handle boolean environment variables', () => {
-      process.env.FLUXSTACK_CORS_CREDENTIALS = 'true'
-      process.env.FLUXSTACK_BUILD_MINIFY = 'false'
-      process.env.MONITORING_ENABLED = 'true'
-
-      const result = loadConfigSync()
-      
-      expect(result.config.server.cors.credentials).toBe(true)
-      expect(result.config.build.optimization.minify).toBe(false)
-      expect(result.config.monitoring.enabled).toBe(true)
-    })
-
-    it('should handle array environment variables', () => {
-      process.env.CORS_ORIGINS = 'http://localhost:3000,http://localhost:5173,https://example.com'
-      process.env.CORS_METHODS = 'GET,POST,PUT,DELETE'
-
-      const result = loadConfigSync()
-      
-      expect(result.config.server.cors.origins).toEqual([
-        'http://localhost:3000',
-        'http://localhost:5173', 
-        'https://example.com'
-      ])
-      expect(result.config.server.cors.methods).toEqual(['GET', 'POST', 'PUT', 'DELETE'])
-    })
-
-    it('should handle custom environment variables', () => {
-      process.env.FLUXSTACK_CUSTOM_FEATURE = 'enabled'
-      process.env.FLUXSTACK_CUSTOM_TIMEOUT = '5000'
-
-      const result = loadConfigSync({ environment: 'development' })
-      
-      expect(result.config.custom?.['custom.feature']).toBe('enabled')
-      expect(result.config.custom?.['custom.timeout']).toBe(5000)
-    })
-
-    it('should apply environment-specific configuration', () => {
-      const originalNodeEnv = process.env.NODE_ENV
-      process.env.NODE_ENV = 'development'
-
-      const result = loadConfigSync()
-      
-      expect(result.config.logging.level).toBe('debug')
-      expect(result.config.logging.format).toBe('pretty')
-      expect(result.sources).toContain('environment:development')
-
-      process.env.NODE_ENV = originalNodeEnv
-    })
-  })
-
-  describe('loadConfig (async)', () => {
-    it('should load configuration from file', async () => {
-      // Create test configuration file
-      const testConfig = `
-        export default {
-          app: {
-            name: 'file-test-app',
-            version: '2.0.0'
-          },
-          server: {
-            port: 8080,
-            host: 'test-host',
-            apiPrefix: '/test-api',
-            cors: {
-              origins: ['http://test.com'],
-              methods: ['GET', 'POST'],
-              headers: ['Content-Type']
-            },
-            middleware: []
-          }
-        }
-      `
-      
-      writeFileSync(testConfigPath, testConfig)
-
-      const result = await loadConfig({ configPath: testConfigPath, environment: 'development' })
-      
-      expect(result.config.app.name).toBe('file-test-app')
-      expect(result.config.server.port).toBe(8080)
-      expect(result.config.server.host).toBe('test-host')
-      expect(result.sources).toContain(`file:${testConfigPath}`)
-    })
-
-    it('should merge file config with environment variables', async () => {
-      process.env.PORT = '9000'
-      process.env.FLUXSTACK_APP_NAME = 'env-override'
-
-      const testConfig = `
-        export default {
-          app: {
-            name: 'file-app',
-            version: '1.0.0'
-          },
-          server: {
-            port: 8080,
-            host: 'localhost',
-            apiPrefix: '/api',
-            cors: {
-              origins: ['http://localhost:3000'],
-              methods: ['GET'],
-              headers: ['Content-Type']
-            },
-            middleware: []
-          }
-        }
-      `
-      
-      writeFileSync(testConfigPath, testConfig)
-
-      const result = await loadConfig({ configPath: testConfigPath, environment: 'development' })
-      
-      // Environment variables should override file config
-      expect(result.config.server.port).toBe(9000)
-      expect(result.config.app.name).toBe('env-override')
-      expect(result.sources).toContain('environment')
-      expect(result.sources).toContain(`file:${testConfigPath}`)
-    })
-
-    it('should handle configuration file errors gracefully', async () => {
-      const result = await loadConfig({ configPath: 'non-existent-config.ts' })
-      
-      expect(result.errors.length).toBeGreaterThan(0)
-      expect(result.config).toBeDefined() // Should fall back to defaults
-    })
-
-    it('should validate configuration when requested', async () => {
-      const invalidConfig = `
-        export default {
-          app: {
-            name: '',
-            version: 'invalid-version'
-          }
-        }
-      `
-      
-      writeFileSync(testConfigPath, invalidConfig)
-
-      const result = await loadConfig({ 
-        configPath: testConfigPath,
-        validateSchema: true 
-      })
-      
-      // Current implementation is lenient - doesn't fail on minor validation issues
-      expect(result.errors.length).toBe(0)
-      expect(result.config).toBeDefined()
-      expect(result.warnings).toBeDefined()
-    })
-  })
-
-  describe('getConfigValue', () => {
-    it('should get nested configuration values', () => {
-      const config = defaultFluxStackConfig
-      
-      expect(getConfigValue(config, 'app.name', '')).toBe(config.app.name)
-      expect(getConfigValue(config, 'server.port', 0)).toBe(config.server.port)
-      expect(getConfigValue(config, 'server.cors.origins', [] as string[])).toEqual(config.server.cors.origins)
-    })
-
-    it('should return default value for missing paths', () => {
-      const config = defaultFluxStackConfig
-      
-      expect(getConfigValue(config, 'nonexistent.path', 'default')).toBe('default')
-      expect(getConfigValue(config, 'app.nonexistent', null)).toBe(null)
-    })
-
-    it('should handle deep nested paths', () => {
-      const config = defaultFluxStackConfig
-      
-      expect(getConfigValue(config, 'build.optimization.minify', false)).toBe(config.build.optimization.minify)
-      expect(getConfigValue(config, 'monitoring.metrics.enabled', false)).toBe(config.monitoring.metrics.enabled)
-    })
-  })
-
-  describe('hasConfigValue', () => {
-    it('should check if configuration values exist', () => {
-      const config = defaultFluxStackConfig
-      
-      expect(hasConfigValue(config, 'app.name')).toBe(true)
-      expect(hasConfigValue(config, 'server.port')).toBe(true)
-      expect(hasConfigValue(config, 'nonexistent.path')).toBe(false)
-    })
-
-    it('should handle optional configurations', () => {
-      const config = { ...defaultFluxStackConfig, database: { url: 'test://db' } }
-      
-      expect(hasConfigValue(config, 'database.url')).toBe(true)
-      expect(hasConfigValue(config, 'database.host')).toBe(false)
-    })
-  })
-
-  describe('createConfigSubset', () => {
-    it('should create configuration subset', () => {
-      const config = defaultFluxStackConfig
-      const paths = ['app.name', 'server.port', 'logging.level']
-      
-      const subset = createConfigSubset(config, paths)
-      
-      expect(subset.app.name).toBe(config.app.name)
-      expect(subset.server.port).toBe(config.server.port)
-      expect(subset.logging.level).toBe(config.logging.level)
-      expect(subset.client).toBeUndefined()
-    })
-
-    it('should handle missing paths gracefully', () => {
-      const config = defaultFluxStackConfig
-      const paths = ['app.name', 'nonexistent.path', 'server.port']
-      
-      const subset = createConfigSubset(config, paths)
-      
-      expect(subset.app.name).toBe(config.app.name)
-      expect(subset.server.port).toBe(config.server.port)
-      expect(subset.nonexistent).toBeUndefined()
-    })
-  })
-
-  describe('Environment Handling', () => {
-    it('should handle different NODE_ENV values', () => {
-      const environments = ['development', 'production', 'test']
-      
-      environments.forEach(env => {
-        process.env.NODE_ENV = env
-        const result = loadConfigSync({ environment: env })
-        
-        expect(result.sources).toContain(`environment:${env}`)
-        expect(result.config).toBeDefined()
-      })
-    })
-
-    it('should apply correct environment defaults', () => {
-      process.env.NODE_ENV = 'production'
-      const result = loadConfigSync({ environment: 'production' })
-      
-      expect(result.config.logging.level).toBe('warn')
-      expect(result.config.logging.format).toBe('json')
-      expect(result.config.monitoring.enabled).toBe(true)
-    })
-
-    it('should handle custom environment names', () => {
-      const result = loadConfigSync({ environment: 'staging' })
-      
-      expect(result.sources).toContain('environment:staging')
-      expect(result.config).toBeDefined()
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should collect and report warnings', () => {
-      process.env.INVALID_ENV_VAR = 'invalid-json-{'
-      
-      const result = loadConfigSync()
-      
-      // Should not fail, but may have warnings
-      expect(result.config).toBeDefined()
-      expect(result.errors).toBeDefined()
-    })
-
-    it('should handle malformed environment variables', () => {
-      process.env.PORT = 'not-a-number'
-      process.env.MONITORING_ENABLED = 'maybe'
-      
-      const result = loadConfigSync()
-      
-      // Should use defaults for invalid values
-      expect(typeof result.config.server.port).toBe('number')
-      expect(typeof result.config.monitoring.enabled).toBe('boolean')
-    })
-  })
-})

package/core/config/__tests__/schema.test.ts

@@ -1,129 +0,0 @@
-/**
- * Tests for FluxStack Configuration Schema
- */
-
-import { describe, it, expect } from 'vitest'
-import {
-    defaultFluxStackConfig,
-    environmentDefaults,
-    fluxStackConfigSchema,
-    type FluxStackConfig
-} from '../schema'
-
-describe('Configuration Schema', () => {
-    describe('defaultFluxStackConfig', () => {
-        it('should have all required properties', () => {
-            expect(defaultFluxStackConfig).toHaveProperty('app')
-            expect(defaultFluxStackConfig).toHaveProperty('server')
-            expect(defaultFluxStackConfig).toHaveProperty('client')
-            expect(defaultFluxStackConfig).toHaveProperty('build')
-            expect(defaultFluxStackConfig).toHaveProperty('plugins')
-            expect(defaultFluxStackConfig).toHaveProperty('logging')
-            expect(defaultFluxStackConfig).toHaveProperty('monitoring')
-        })
-
-        it('should have valid app configuration', () => {
-            expect(defaultFluxStackConfig.app.name).toBe('fluxstack-app')
-            expect(defaultFluxStackConfig.app.version).toBe('1.0.0')
-            expect(defaultFluxStackConfig.app.description).toBe('A FluxStack application')
-        })
-
-        it('should have valid server configuration', () => {
-            expect(defaultFluxStackConfig.server.port).toBe(3000)
-            expect(defaultFluxStackConfig.server.host).toBe('localhost')
-            expect(defaultFluxStackConfig.server.apiPrefix).toBe('/api')
-            expect(defaultFluxStackConfig.server.cors.origins).toContain('http://localhost:3000')
-            expect(defaultFluxStackConfig.server.cors.methods).toContain('GET')
-        })
-
-        it('should have valid client configuration', () => {
-            expect(defaultFluxStackConfig.client.port).toBe(5173)
-            expect(defaultFluxStackConfig.client.proxy.target).toBe('http://localhost:3000')
-            expect(defaultFluxStackConfig.client.build.sourceMaps).toBe(true)
-        })
-
-        it('should have valid build configuration', () => {
-            expect(defaultFluxStackConfig.build.target).toBe('bun')
-            expect(defaultFluxStackConfig.build.outDir).toBe('dist')
-            expect(defaultFluxStackConfig.build.optimization.minify).toBe(true)
-        })
-    })
-
-    describe('environmentDefaults', () => {
-        it('should have development overrides', () => {
-            expect(environmentDefaults.development.logging?.level).toBe('debug')
-            expect(environmentDefaults.development.logging?.format).toBe('pretty')
-            expect(environmentDefaults.development.build?.optimization.minify).toBe(false)
-        })
-
-        it('should have production overrides', () => {
-            expect(environmentDefaults.production.logging?.level).toBe('warn')
-            expect(environmentDefaults.production.logging?.format).toBe('json')
-            expect(environmentDefaults.production.monitoring?.enabled).toBe(true)
-        })
-
-        it('should have test overrides', () => {
-            expect(environmentDefaults.test.logging?.level).toBe('error')
-            expect(environmentDefaults.test.server?.port).toBe(0)
-            expect(environmentDefaults.test.client?.port).toBe(0)
-        })
-    })
-
-    describe('fluxStackConfigSchema', () => {
-        it('should be a valid JSON schema', () => {
-            expect(fluxStackConfigSchema).toHaveProperty('type', 'object')
-            expect(fluxStackConfigSchema).toHaveProperty('properties')
-            expect(fluxStackConfigSchema).toHaveProperty('required')
-        })
-
-        it('should require essential properties', () => {
-            const required = fluxStackConfigSchema.required
-            expect(required).toContain('app')
-            expect(required).toContain('server')
-            expect(required).toContain('client')
-            expect(required).toContain('build')
-            expect(required).toContain('plugins')
-            expect(required).toContain('logging')
-            expect(required).toContain('monitoring')
-        })
-
-        it('should have proper app schema', () => {
-            const appSchema = fluxStackConfigSchema.properties.app
-            expect(appSchema.required).toContain('name')
-            expect(appSchema.required).toContain('version')
-            expect(appSchema.properties.version.pattern).toBe('^\\d+\\.\\d+\\.\\d+')
-        })
-
-        it('should have proper server schema', () => {
-            const serverSchema = fluxStackConfigSchema.properties.server
-            expect(serverSchema.properties.port.minimum).toBe(1)
-            expect(serverSchema.properties.port.maximum).toBe(65535)
-            expect(serverSchema.required).toContain('cors')
-        })
-    })
-
-    describe('Type Safety', () => {
-        it('should accept valid configuration', () => {
-            const validConfig: FluxStackConfig = {
-                ...defaultFluxStackConfig,
-                app: {
-                    name: 'test-app',
-                    version: '2.0.0'
-                }
-            }
-
-            expect(validConfig.app.name).toBe('test-app')
-            expect(validConfig.server.port).toBe(3000)
-        })
-
-        it('should enforce type constraints', () => {
-            // TypeScript should catch these at compile time
-            // This test ensures our types are properly defined
-            const config: FluxStackConfig = defaultFluxStackConfig
-
-            expect(typeof config.server.port).toBe('number')
-            expect(Array.isArray(config.server.cors.origins)).toBe(true)
-            expect(typeof config.build.optimization.minify).toBe('boolean')
-        })
-    })
-})