create-fluxstack 1.0.2 → 1.0.3

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

@@ -0,0 +1,268 @@
+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

@@ -0,0 +1,188 @@
+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')
+    })
+  })
+})

package/tests/utils/test-helpers.ts

@@ -0,0 +1,61 @@
+import type { ReactElement } from 'react'
+import { render, type RenderOptions } from '@testing-library/react'
+
+// Custom render function that can include providers
+const customRender = (
+  ui: ReactElement,
+  options?: Omit<RenderOptions, 'wrapper'>
+) => render(ui, {
+  // Add any providers here (e.g., ThemeProvider, QueryClient, etc.)
+  ...options,
+})
+
+export * from '@testing-library/react'
+export { customRender as render }
+
+// Test utilities
+export const waitForLoadingToFinish = () => 
+  new Promise(resolve => setTimeout(resolve, 0))
+
+export const createMockUser = (overrides = {}) => ({
+  id: Math.floor(Math.random() * 1000),
+  name: 'Test User',
+  email: 'test@example.com',
+  createdAt: new Date(),
+  ...overrides
+})
+
+export const createMockRequest = (url: string, options: RequestInit = {}) => 
+  new Request(url, {
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers,
+    },
+    ...options,
+  })
+
+// Mock API helpers
+export const mockApiSuccess = <T>(data: T) => ({
+  data,
+  status: 200,
+  ok: true
+})
+
+export const mockApiError = (message: string, status = 400) => ({
+  error: message,
+  status,
+  ok: false
+})
+
+// Environment helpers
+export const setTestEnv = (vars: Record<string, string>) => {
+  Object.entries(vars).forEach(([key, value]) => {
+    Bun.env[key] = value
+  })
+}
+
+export const resetTestEnv = (keys: string[]) => {
+  keys.forEach(key => {
+    delete Bun.env[key]
+  })
+}

package/tsconfig.json

@@ -0,0 +1,51 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["node"],
+    "typeRoots": ["./types", "./node_modules/@types"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "downlevelIteration": true,
+
+    // Path mapping (alias support)
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./*"],
+      "@/core/*": ["./core/*"],
+      "@/app/*": ["./app/*"],
+      "@/config/*": ["./config/*"],
+      "@/shared/*": ["./app/shared/*"]
+    },
+
+    // Best practices
+    "strict": false,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": false,
+    "strictNullChecks": false,
+    "strictFunctionTypes": false,
+    "noImplicitReturns": false,
+    "noImplicitThis": false,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "exclude": [
+    "examples/**/*",
+    "**/*.test.ts",
+    "**/__tests__/**/*",
+    "run-env-tests.ts"
+  ]
+}

package/types/global.d.ts

@@ -0,0 +1,30 @@
+// Global type fixes for FluxStack
+
+declare global {
+  interface Window {
+    location: {
+      hostname: string
+      port: string
+      protocol: string
+      origin: string
+    }
+  }
+}
+
+// Fix for unknown types
+declare module "*" {
+  const content: any
+  export = content
+}
+
+// Environment types
+declare const process: {
+  env: Record<string, string | undefined>
+}
+
+declare const Bun: {
+  env: Record<string, string | undefined>
+  spawn: (options: any) => any
+}
+
+export {}

package/types/vitest.d.ts

@@ -0,0 +1,9 @@
+declare global {
+  function beforeEach(fn: () => void): void
+  function describe(name: string, fn: () => void): void
+  function it(name: string, fn: () => void): void
+  function test(name: string, fn: () => void): void
+  function expect(value: any): any
+}
+
+export {}

package/vite.config.ts

@@ -0,0 +1,42 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { resolve } from 'path'
+import { fileURLToPath, URL } from 'node:url'
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  root: 'app/client',
+  server: {
+    port: 5173,
+    host: true,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:3000',
+        changeOrigin: true,
+        secure: false,
+      }
+    }
+  },
+  build: {
+    outDir: '../../dist/client'
+  },
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './app/client/src'),
+      '@/core': resolve(__dirname, './core'),
+      '@/app': resolve(__dirname, './app'),
+      '@/config': resolve(__dirname, './config'),
+      '@/shared': resolve(__dirname, './app/shared'),
+      '@/components': resolve(__dirname, './app/client/src/components'),
+      '@/utils': resolve(__dirname, './app/client/src/utils'),
+      '@/hooks': resolve(__dirname, './app/client/src/hooks'),
+      '@/assets': resolve(__dirname, './app/client/src/assets'),
+      '@/lib': resolve(__dirname, './app/client/src/lib'),
+      '@/types': resolve(__dirname, './app/client/src/types')
+    }
+  }
+})

package/vitest.config.ts

@@ -0,0 +1,50 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vitest/config'
+import { resolve } from 'path'
+import { fileURLToPath, URL } from 'node:url'
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
+
+export default defineConfig({
+  plugins: [],
+  test: {
+    globals: true,
+    setupFiles: ['./tests/setup.ts'],
+    testTimeout: 5000,
+    projects: [
+      {
+        name: 'frontend',
+        testMatch: ['**/app/client/**/*.{test,spec}.{js,ts,jsx,tsx}', '**/tests/unit/app/client/**/*.{test,spec}.{js,ts,jsx,tsx}'],
+        environment: 'jsdom'
+      },
+      {
+        name: 'backend',
+        testMatch: ['**/core/**/*.{test,spec}.{js,ts}', '**/app/server/**/*.{test,spec}.{js,ts}', '**/tests/unit/app/controllers/**/*.{test,spec}.{js,ts}', '**/tests/integration/**/*.{test,spec}.{js,ts}'],
+        environment: 'node'
+      }
+    ],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        'build/',
+        'tests/',
+        '**/*.d.ts',
+        '**/*.config.{js,ts}',
+        '**/coverage/**'
+      ]
+    }
+  },
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, '.'),
+      '@/core': resolve(__dirname, './core'),
+      '@/app': resolve(__dirname, './app'),
+      '@/config': resolve(__dirname, './config'),
+      '@/shared': resolve(__dirname, './app/shared'),
+      '@/tests': resolve(__dirname, './tests')
+    }
+  }
+})