create-fluxstack 1.0.13 → 1.0.15

package/tests/unit/core/create-project.test.ts.skip

@@ -1,95 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { ProjectCreator } from '@/core/templates/create-project'
-import { rmdir, mkdir } from 'fs/promises'
-import { join } from 'path'
-
-// Mock bun APIs to avoid actual file operations in tests
-vi.mock('bun', async () => {
-  const actual = await vi.importActual('bun')
-  return {
-    ...actual,
-    spawn: vi.fn(() => ({
-      exited: Promise.resolve(0),
-      stdout: { readable: null },
-      stderr: { readable: null }
-    })),
-    write: vi.fn(),
-    file: vi.fn(() => ({
-      exists: () => true,
-      text: () => 'mock content'
-    }))
-  }
-})
-
-vi.mock('fs/promises', () => ({
-  mkdir: vi.fn(),
-  readdir: vi.fn(() => [])
-}))
-
-describe('ProjectCreator', () => {
-  const testDir = join(process.cwd(), 'test-project-temp')
-  let creator: ProjectCreator
-
-  beforeEach(() => {
-    creator = new ProjectCreator({
-      name: 'test-project',
-      targetDir: testDir,
-      template: 'basic'
-    })
-    vi.clearAllMocks()
-  })
-
-  afterEach(async () => {
-    try {
-      await rmdir(testDir, { recursive: true })
-    } catch {
-      // Ignore cleanup errors
-    }
-  })
-
-  describe('constructor', () => {
-    it('should create ProjectCreator with basic options', () => {
-      expect(creator).toBeDefined()
-    })
-
-    it('should set default template to basic', () => {
-      const defaultCreator = new ProjectCreator({
-        name: 'test-project'
-      })
-      expect(defaultCreator).toBeDefined()
-    })
-
-    it('should handle custom target directory', () => {
-      const customCreator = new ProjectCreator({
-        name: 'custom-project',
-        targetDir: '/custom/path',
-        template: 'full'
-      })
-      expect(customCreator).toBeDefined()
-    })
-  })
-
-  describe('validation', () => {
-    it('should validate project names correctly', () => {
-      // Valid names
-      expect(() => new ProjectCreator({ name: 'valid-name' })).not.toThrow()
-      expect(() => new ProjectCreator({ name: 'valid_name' })).not.toThrow()
-      expect(() => new ProjectCreator({ name: 'validName123' })).not.toThrow()
-    })
-  })
-
-  describe('create method', () => {
-    it('should handle create process without throwing', async () => {
-      // Mock all async operations to succeed
-      const mkdirMock = vi.mocked(mkdir)
-      mkdirMock.mockResolvedValue(undefined)
-
-      // We'll test that the method doesn't throw
-      // Full integration testing would require actual file system operations
-      expect(async () => {
-        // In a real test, we'd mock all the dependencies properly
-        // For now, we just ensure the class is properly structured
-      }).not.toThrow()
-    })
-  })
-})

package/tests/unit/core/framework.test.ts

@@ -1,144 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { FluxStackFramework } from '@/core/server/framework'
-import type { Plugin } from '@/core/types'
-import type { FluxStackConfig } from '@/core/config/schema'
-
-describe('FluxStackFramework', () => {
-  let framework: FluxStackFramework
-
-  beforeEach(() => {
-    framework = new FluxStackFramework({
-      server: {
-        port: 3001,
-        host: 'localhost',
-        apiPrefix: '/api',
-        cors: {
-          origins: ['*'],
-          methods: ['GET', 'POST'],
-          headers: ['Content-Type'],
-          credentials: false,
-          maxAge: 86400
-        },
-        middleware: []
-      }
-    })
-  })
-
-  describe('constructor', () => {
-    it('should create framework with default config', () => {
-      const defaultFramework = new FluxStackFramework()
-      const context = defaultFramework.getContext()
-      
-      // Environment variables now control default values
-      expect(context.config.server.port).toBeDefined()
-      expect(context.config.server.apiPrefix).toBe('/api')
-      expect(context.config.client.port).toBeDefined()
-    })
-
-    it('should create framework with custom config', () => {
-      const config: Partial<FluxStackConfig> = {
-        server: {
-          port: 4000,
-          host: 'localhost',
-          apiPrefix: '/custom-api',
-          cors: {
-            origins: ['*'],
-            methods: ['GET', 'POST'],
-            headers: ['Content-Type'],
-            credentials: false,
-            maxAge: 86400
-          },
-          middleware: []
-        },
-        client: {
-          port: 5174,
-          proxy: {
-            target: 'http://localhost:4000',
-            changeOrigin: true
-          },
-          build: {
-            outDir: 'dist/client',
-            sourceMaps: true,
-            minify: false,
-            target: 'es2020'
-          }
-        }
-      }
-      
-      const customFramework = new FluxStackFramework(config)
-      const context = customFramework.getContext()
-      
-      expect(context.config.server.port).toBe(4000)
-      expect(context.config.client.port).toBe(5174)
-      expect(context.config.server.apiPrefix).toBe('/custom-api')
-    })
-
-    it('should set development mode correctly', () => {
-      const context = framework.getContext()
-      // Environment config manages NODE_ENV now
-      expect(typeof context.isDevelopment).toBe('boolean')
-      expect(typeof context.isProduction).toBe('boolean')
-    })
-  })
-
-  describe('plugin system', () => {
-    it('should add plugins correctly', () => {
-      const mockPlugin: Plugin = {
-        name: 'test-plugin',
-        setup: () => {}
-      }
-
-      const result = framework.use(mockPlugin)
-      expect(result).toBe(framework) // Should return framework for chaining
-    })
-
-    it('should handle multiple plugins', () => {
-      const plugin1: Plugin = {
-        name: 'plugin-1',
-        setup: () => {}
-      }
-      
-      const plugin2: Plugin = {
-        name: 'plugin-2',
-        setup: () => {}
-      }
-
-      framework.use(plugin1).use(plugin2)
-      // Framework should not throw and should allow chaining
-      expect(framework).toBeDefined()
-    })
-  })
-
-  describe('routes', () => {
-    it('should register routes correctly', () => {
-      // Test that routes method exists and returns framework
-      expect(typeof framework.routes).toBe('function')
-      
-      // Skip actual route registration test to avoid Elysia mock complexity
-      // This test verifies the method is available for chaining
-      expect(framework).toBeDefined()
-    })
-  })
-
-  describe('getApp', () => {
-    it('should return Elysia app instance', () => {
-      const app = framework.getApp()
-      expect(app).toBeDefined()
-      // Elysia apps have these methods
-      expect(typeof app.get).toBe('function')
-      expect(typeof app.post).toBe('function')
-      expect(typeof app.listen).toBe('function')
-    })
-  })
-
-  describe('getContext', () => {
-    it('should return framework context', () => {
-      const context = framework.getContext()
-      
-      expect(context).toBeDefined()
-      expect(context.config).toBeDefined()
-      expect(typeof context.isDevelopment).toBe('boolean')
-      expect(typeof context.isProduction).toBe('boolean')
-    })
-  })
-})

package/tests/unit/core/plugins/logger.test.ts.skip

@@ -1,268 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { loggerPlugin } from '@/core/server/plugins/logger'
-import type { FluxStackContext } from '@/core/types'
-
-describe('Logger Plugin', () => {
-  let mockContext: FluxStackContext
-  let mockApp: any
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    
-    mockContext = {
-      config: {
-        port: 3000,
-        vitePort: 5173,
-        clientPath: 'app/client',
-        apiPrefix: '/api',
-        cors: {
-          origins: ['http://localhost:5173'],
-          methods: ['GET', 'POST'],
-          headers: ['Content-Type']
-        },
-        build: {
-          outDir: 'dist',
-          target: 'es2020'
-        }
-      },
-      isDevelopment: true,
-      isProduction: false,
-      envConfig: {}
-    } as FluxStackContext
-
-    mockApp = {
-      onRequest: vi.fn(),
-      onResponse: vi.fn(),
-      onError: vi.fn(),
-      use: vi.fn()
-    }
-  })
-
-  describe('Plugin Setup', () => {
-    it('should have correct plugin name', () => {
-      expect(loggerPlugin.name).toBe('logger')
-    })
-
-    it('should have setup function', () => {
-      expect(typeof loggerPlugin.setup).toBe('function')
-    })
-
-    it('should setup logger middleware', () => {
-      loggerPlugin.setup(mockContext, mockApp)
-      
-      // Should register onRequest, onResponse, and onError handlers
-      expect(mockApp.onRequest).toHaveBeenCalledWith(expect.any(Function))
-      expect(mockApp.onResponse).toHaveBeenCalledWith(expect.any(Function))
-      expect(mockApp.onError).toHaveBeenCalledWith(expect.any(Function))
-    })
-  })
-
-  describe('Request Logging', () => {
-    it('should log request details', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-      
-      loggerPlugin.setup(mockContext, mockApp)
-      
-      // Get the onRequest handler
-      const onRequestHandler = mockApp.onRequest.mock.calls[0][0]
-      
-      const mockRequest = new Request('http://localhost:3000/api/users', {
-        method: 'GET',
-        headers: {
-          'user-agent': 'test-agent',
-          'accept': 'application/json'
-        }
-      })
-      
-      const mockContext = {
-        request: mockRequest,
-        set: {}
-      }
-      
-      onRequestHandler(mockContext)
-      
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('📥'),
-        expect.stringContaining('GET'),
-        expect.stringContaining('/api/users')
-      )
-      
-      consoleSpy.mockRestore()
-    })
-
-    it('should log POST requests with different styling', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-      
-      loggerPlugin.setup(mockContext, mockApp)
-      
-      const onRequestHandler = mockApp.onRequest.mock.calls[0][0]
-      
-      const mockRequest = new Request('http://localhost:3000/api/users', {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json'
-        }
-      })
-      
-      const mockContext = {
-        request: mockRequest,
-        set: {}
-      }
-      
-      onRequestHandler(mockContext)
-      
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('📥'),
-        expect.stringContaining('POST'),
-        expect.stringContaining('/api/users')
-      )
-      
-      consoleSpy.mockRestore()
-    })
-  })
-
-  describe('Response Logging', () => {
-    it('should log successful responses', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-      
-      loggerPlugin.setup(mockContext, mockApp)
-      
-      const onResponseHandler = mockApp.onResponse.mock.calls[0][0]
-      
-      const mockRequest = new Request('http://localhost:3000/api/users', {
-        method: 'GET'
-      })
-      
-      const mockResponse = new Response('{"users": []}', {
-        status: 200,
-        statusText: 'OK',
-        headers: {
-          'content-type': 'application/json'
-        }
-      })
-      
-      const mockContext = {
-        request: mockRequest,
-        response: mockResponse,
-        set: { status: 200 }
-      }
-      
-      onResponseHandler(mockContext)
-      
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('📤'),
-        expect.stringContaining('GET'),
-        expect.stringContaining('/api/users'),
-        expect.stringContaining('200')
-      )
-      
-      consoleSpy.mockRestore()
-    })
-
-    it('should log error responses differently', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-      
-      loggerPlugin.setup(mockContext, mockApp)
-      
-      const onResponseHandler = mockApp.onResponse.mock.calls[0][0]
-      
-      const mockRequest = new Request('http://localhost:3000/api/users/999', {
-        method: 'GET'
-      })
-      
-      const mockResponse = new Response('{"error": "Not found"}', {
-        status: 404,
-        statusText: 'Not Found'
-      })
-      
-      const mockContext = {
-        request: mockRequest,
-        response: mockResponse,
-        set: { status: 404 }
-      }
-      
-      onResponseHandler(mockContext)
-      
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('📤'),
-        expect.stringContaining('GET'),
-        expect.stringContaining('/api/users/999'),
-        expect.stringContaining('404')
-      )
-      
-      consoleSpy.mockRestore()
-    })
-  })
-
-  describe('Error Logging', () => {
-    it('should log errors with stack trace', () => {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      
-      loggerPlugin.setup(mockContext, mockApp)
-      
-      const onErrorHandler = mockApp.onError.mock.calls[0][0]
-      
-      const mockError = new Error('Test error')
-      const mockRequest = new Request('http://localhost:3000/api/test')
-      
-      const mockContext = {
-        error: mockError,
-        request: mockRequest,
-        set: {}
-      }
-      
-      onErrorHandler(mockContext)
-      
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('❌ Error:'),
-        expect.stringContaining('Test error')
-      )
-      
-      consoleSpy.mockRestore()
-    })
-
-    it('should handle errors without stack trace', () => {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      
-      loggerPlugin.setup(mockContext, mockApp)
-      
-      const onErrorHandler = mockApp.onError.mock.calls[0][0]
-      
-      const mockError = { message: 'Simple error' }
-      const mockRequest = new Request('http://localhost:3000/api/test')
-      
-      const mockContext = {
-        error: mockError,
-        request: mockRequest,
-        set: {}
-      }
-      
-      onErrorHandler(mockContext)
-      
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('❌ Error:'),
-        expect.stringContaining('Simple error')
-      )
-      
-      consoleSpy.mockRestore()
-    })
-  })
-
-  describe('Development vs Production', () => {
-    it('should work in production mode', () => {
-      const productionContext = {
-        ...mockContext,
-        isDevelopment: false,
-        isProduction: true
-      }
-      
-      expect(() => {
-        loggerPlugin.setup(productionContext, mockApp)
-      }).not.toThrow()
-      
-      expect(mockApp.onRequest).toHaveBeenCalled()
-      expect(mockApp.onResponse).toHaveBeenCalled()
-      expect(mockApp.onError).toHaveBeenCalled()
-    })
-  })
-})

package/tests/unit/core/plugins/vite.test.ts.disabled

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-
-// Mock global fetch before any other imports
-Object.defineProperty(global, 'fetch', {
-  value: vi.fn(),
-  writable: true,
-  configurable: true
-})
-import { vitePlugin } from '@/core/plugins/built-in/vite'
-import type { PluginContext } from '@/core/types'
-
-// Remove duplicate global fetch assignment as it's now set above
-
-describe.skip('Vite Plugin', () => {
-  let mockContext: PluginContext
-  let mockApp: any
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.clearAllTimers()
-    vi.useFakeTimers()
-
-    mockContext = {
-      config: {
-        server: { port: 3000, host: 'localhost', apiPrefix: '/api', cors: { origins: [], methods: [], headers: [] }, middleware: [] },
-        client: { port: 5173, proxy: { target: 'http://localhost:3000' }, build: { outDir: 'dist', target: 'es2020', sourceMaps: true, minify: false } },
-        app: { name: 'test', version: '1.0.0' }
-      },
-      logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn(), child: vi.fn(), time: vi.fn(), timeEnd: vi.fn(), request: vi.fn() },
-      app: mockApp,
-      utils: {
-        isDevelopment: vi.fn(() => true),
-        isProduction: vi.fn(() => false),
-        createTimer: vi.fn(),
-        formatBytes: vi.fn(),
-        getEnvironment: vi.fn(() => 'test'),
-        createHash: vi.fn(),
-        deepMerge: vi.fn(),
-        validateSchema: vi.fn()
-      }
-    } as any
-
-    mockApp = {
-      get: vi.fn(),
-      post: vi.fn(),
-      use: vi.fn()
-    }
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  describe('Development Mode', () => {
-    it('should set up plugin in development mode', async () => {
-      await vitePlugin.setup!(mockContext)
-      
-      expect(mockContext.logger.info).toHaveBeenCalledWith('Setting up Vite integration on localhost:5173')
-    })
-
-    it('should check for Vite after timeout', async () => {
-      // Mock successful Vite check
-      vi.mocked(fetch).mockResolvedValueOnce({
-        status: 200,
-        ok: true
-      } as Response)
-      
-      await vitePlugin.setup!(mockContext)
-      
-      // Fast-forward timers to trigger the setTimeout
-      vi.advanceTimersByTime(2000)
-      
-      // Wait for the async operation to complete
-      await vi.runAllTimersAsync()
-      
-      expect(fetch).toHaveBeenCalledWith('http://localhost:5173', {
-        signal: expect.any(AbortSignal)
-      })
-      
-      expect(mockContext.logger.info).toHaveBeenCalledWith('✓ Vite server detected on localhost:5173')
-      expect(mockContext.logger.info).toHaveBeenCalledWith('Hot reload coordination active')
-    })
-
-    it('should handle Vite check failure silently', async () => {
-      // Mock failed Vite check
-      vi.mocked(fetch).mockRejectedValueOnce(new Error('Connection refused'))
-      
-      await vitePlugin.setup!(mockContext)
-      
-      // Fast-forward timers
-      vi.advanceTimersByTime(2000)
-      await vi.runAllTimersAsync()
-      
-      expect(fetch).toHaveBeenCalledWith('http://localhost:5173', {
-        signal: expect.any(AbortSignal)
-      })
-      
-      // Should not log success messages when Vite is not running
-      expect(mockContext.logger.info).not.toHaveBeenCalledWith('✓ Vite server detected on localhost:5173')
-    })
-
-    it('should use custom vite port from context', async () => {
-      const customContext = {
-        ...mockContext,
-        config: {
-          ...mockContext.config,
-          client: { ...mockContext.config.client, port: 3001 }
-        }
-      }
-      
-      vi.mocked(fetch).mockResolvedValueOnce({
-        status: 200,
-        ok: true
-      } as Response)
-      
-      await vitePlugin.setup!(customContext)
-      
-      expect(customContext.logger.info).toHaveBeenCalledWith('Setting up Vite integration on localhost:3001')
-      
-      vi.advanceTimersByTime(2000)
-      await vi.runAllTimersAsync()
-      
-      expect(fetch).toHaveBeenCalledWith('http://localhost:3001', {
-        signal: expect.any(AbortSignal)
-      })
-    })
-  })
-
-  describe('Production Mode', () => {
-    it('should skip plugin setup in production mode', async () => {
-      const productionContext = {
-        ...mockContext,
-        utils: {
-          ...mockContext.utils,
-          isDevelopment: vi.fn(() => false),
-          isProduction: vi.fn(() => true)
-        }
-      }
-      
-      await vitePlugin.setup!(productionContext)
-      
-      expect(productionContext.logger.info).not.toHaveBeenCalled()
-      expect(fetch).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Plugin Properties', () => {
-    it('should have correct plugin name', () => {
-      expect(vitePlugin.name).toBe('vite')
-    })
-
-    it('should have setup function', () => {
-      expect(typeof vitePlugin.setup).toBe('function')
-    })
-  })
-
-  describe('checkViteRunning function', () => {
-    it('should return true for successful connection', async () => {
-      vi.mocked(fetch).mockResolvedValueOnce({
-        status: 200,
-        ok: true
-      } as Response)
-
-      // We need to access the checkViteRunning function
-      // Since it's not exported, we'll test it indirectly through the plugin
-      await vitePlugin.setup!(mockContext)
-      vi.advanceTimersByTime(2000)
-      await vi.runAllTimersAsync()
-
-      expect(mockContext.logger.info).toHaveBeenCalledWith('✓ Vite server detected on localhost:5173')
-    })
-
-    it('should return false for connection timeout', async () => {
-      vi.mocked(fetch).mockImplementationOnce(() => 
-        new Promise((_, reject) => {
-          setTimeout(() => reject(new Error('timeout')), 1500)
-        })
-      )
-      
-      await vitePlugin.setup!(mockContext)
-      vi.advanceTimersByTime(2000)
-      await vi.runAllTimersAsync()
-
-      // Should not show success message when timeout occurs
-      expect(mockContext.logger.info).not.toHaveBeenCalledWith('✓ Vite server detected on localhost:5173')
-    })
-  })
-})