create-fluxstack 1.0.0

package/core/framework/__tests__/server.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Tests for FluxStack Framework Server
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { FluxStackFramework } from '../server'
+import type { Plugin } from '../../plugins/types'
+
+// Mock dependencies
+vi.mock('../../config', () => ({
+  getConfigSync: vi.fn(() => ({
+    server: {
+      port: 3000,
+      apiPrefix: '/api',
+      cors: {
+        origins: ['*'],
+        methods: ['GET', 'POST'],
+        headers: ['Content-Type'],
+        credentials: false
+      }
+    },
+    app: {
+      name: 'test-app',
+      version: '1.0.0'
+    }
+  })),
+  getEnvironmentInfo: vi.fn(() => ({
+    isDevelopment: true,
+    isProduction: false,
+    isTest: true,
+    name: 'test'
+  }))
+}))
+
+vi.mock('../../utils/logger', () => ({
+  logger: {
+    framework: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(() => ({
+      framework: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn()
+    }))
+  }
+}))
+
+vi.mock('../../utils/errors/handlers', () => ({
+  createErrorHandler: vi.fn(() => vi.fn())
+}))
+
+vi.mock('elysia', () => ({
+  Elysia: vi.fn(() => ({
+    onRequest: vi.fn().mockReturnThis(),
+    onAfterHandle: vi.fn().mockReturnThis(),
+    onError: vi.fn().mockReturnThis(),
+    options: vi.fn().mockReturnThis(),
+    use: vi.fn().mockReturnThis(),
+    listen: vi.fn((_port, callback) => {
+      if (callback) callback()
+    })
+  }))
+}))
+
+describe('FluxStackFramework', () => {
+  let framework: FluxStackFramework
+
+  beforeEach(() => {
+    framework = new FluxStackFramework()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('Constructor', () => {
+    it('should initialize framework with default config', () => {
+      expect(framework).toBeInstanceOf(FluxStackFramework)
+      expect(framework.getContext()).toBeDefined()
+      expect(framework.getApp()).toBeDefined()
+      expect(framework.getPluginRegistry()).toBeDefined()
+    })
+
+    it('should initialize framework with custom config', () => {
+      const customConfig = {
+        server: {
+          port: 4000,
+          host: 'localhost',
+          apiPrefix: '/custom-api',
+          cors: {
+            origins: ['*'],
+            methods: ['GET', 'POST'],
+            headers: ['Content-Type'],
+            credentials: false,
+            maxAge: 86400
+          },
+          middleware: []
+        }
+      }
+      
+      const customFramework = new FluxStackFramework(customConfig)
+      const context = customFramework.getContext()
+      
+      expect(context.config.server.port).toBe(4000)
+      expect(context.config.server.apiPrefix).toBe('/custom-api')
+    })
+
+    it('should set up context correctly', () => {
+      const context = framework.getContext()
+      
+      expect(context.isDevelopment).toBe(true)
+      expect(context.isProduction).toBe(false)
+      expect(context.isTest).toBe(true)
+      expect(context.environment).toBe('test')
+    })
+  })
+
+  describe('Plugin Management', () => {
+    it('should register plugins successfully', () => {
+      const mockPlugin: Plugin = {
+        name: 'test-plugin',
+        setup: vi.fn()
+      }
+
+      expect(() => framework.use(mockPlugin)).not.toThrow()
+      expect(framework.getPluginRegistry().get('test-plugin')).toBe(mockPlugin)
+    })
+
+    it('should throw error when registering duplicate plugin', () => {
+      const mockPlugin: Plugin = {
+        name: 'duplicate-plugin',
+        setup: vi.fn()
+      }
+
+      framework.use(mockPlugin)
+      expect(() => framework.use(mockPlugin)).toThrow()
+    })
+
+    it('should validate plugin dependencies', async () => {
+      const pluginA: Plugin = {
+        name: 'plugin-a',
+        setup: vi.fn()
+      }
+
+      const pluginB: Plugin = {
+        name: 'plugin-b',
+        dependencies: ['plugin-a'],
+        setup: vi.fn()
+      }
+
+      framework.use(pluginA)
+      framework.use(pluginB)
+
+      await expect(framework.start()).resolves.not.toThrow()
+    })
+
+    it('should throw error for missing dependencies', async () => {
+      const pluginWithMissingDep: Plugin = {
+        name: 'plugin-with-missing-dep',
+        dependencies: ['non-existent-plugin'],
+        setup: vi.fn()
+      }
+
+      framework.use(pluginWithMissingDep)
+      await expect(framework.start()).rejects.toThrow()
+    })
+  })
+
+  describe('Lifecycle Management', () => {
+    it('should start framework successfully', async () => {
+      const mockPlugin: Plugin = {
+        name: 'lifecycle-plugin',
+        setup: vi.fn(),
+        onServerStart: vi.fn()
+      }
+
+      framework.use(mockPlugin)
+      await framework.start()
+
+      expect(mockPlugin.setup).toHaveBeenCalled()
+      expect(mockPlugin.onServerStart).toHaveBeenCalled()
+    })
+
+    it('should stop framework successfully', async () => {
+      const mockPlugin: Plugin = {
+        name: 'lifecycle-plugin',
+        setup: vi.fn(),
+        onServerStart: vi.fn(),
+        onServerStop: vi.fn()
+      }
+
+      framework.use(mockPlugin)
+      await framework.start()
+      await framework.stop()
+
+      expect(mockPlugin.onServerStop).toHaveBeenCalled()
+    })
+
+    it('should not start framework twice', async () => {
+      await framework.start()
+      await framework.start() // Should not throw or cause issues
+      
+      // Should log warning about already started
+      const { logger } = await import('../../utils/logger')
+      expect(logger.warn).toHaveBeenCalled()
+    })
+
+    it('should handle plugin setup errors', async () => {
+      const errorPlugin: Plugin = {
+        name: 'error-plugin',
+        setup: vi.fn().mockRejectedValue(new Error('Setup failed'))
+      }
+
+      framework.use(errorPlugin)
+      await expect(framework.start()).rejects.toThrow('Setup failed')
+    })
+  })
+
+  describe('Routes', () => {
+    it('should add routes to the app', () => {
+      const mockRouteModule = { get: vi.fn() }
+      
+      expect(() => framework.routes(mockRouteModule)).not.toThrow()
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should set up error handling', async () => {
+      const { createErrorHandler } = await import('../../utils/errors/handlers')
+      expect(createErrorHandler).toHaveBeenCalled()
+    })
+  })
+})

package/core/framework/client.ts

@@ -0,0 +1,132 @@
+/**
+ * FluxStack Client Framework Utilities
+ * Provides client-side utilities and integrations
+ */
+
+import type { FluxStackConfig } from "../types"
+
+export interface ClientFrameworkOptions {
+  config: FluxStackConfig
+  baseUrl?: string
+  timeout?: number
+  retries?: number
+}
+
+export class FluxStackClient {
+  private config: FluxStackConfig
+  private baseUrl: string
+  private timeout: number
+  private retries: number
+
+  constructor(options: ClientFrameworkOptions) {
+    this.config = options.config
+    this.baseUrl = options.baseUrl || `http://localhost:${options.config.server.port}`
+    this.timeout = options.timeout || 10000
+    this.retries = options.retries || 3
+  }
+
+  // Create a configured fetch client
+  createFetchClient() {
+    return async (url: string, options: RequestInit = {}) => {
+      const fullUrl = url.startsWith('http') ? url : `${this.baseUrl}${url}`
+      
+      const requestOptions: RequestInit = {
+        ...options,
+        headers: {
+          'Content-Type': 'application/json',
+          ...options.headers
+        }
+      }
+
+      // Add timeout
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout)
+      requestOptions.signal = controller.signal
+
+      try {
+        const response = await fetch(fullUrl, requestOptions)
+        clearTimeout(timeoutId)
+        
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+        }
+        
+        return response
+      } catch (error) {
+        clearTimeout(timeoutId)
+        throw error
+      }
+    }
+  }
+
+  // Create API client with retry logic
+  createApiClient() {
+    const fetchClient = this.createFetchClient()
+    
+    return {
+      get: async <T>(url: string): Promise<T> => {
+        return this.withRetry(async () => {
+          const response = await fetchClient(url, { method: 'GET' })
+          return response.json()
+        })
+      },
+      
+      post: async <T>(url: string, data: any): Promise<T> => {
+        return this.withRetry(async () => {
+          const response = await fetchClient(url, {
+            method: 'POST',
+            body: JSON.stringify(data)
+          })
+          return response.json()
+        })
+      },
+      
+      put: async <T>(url: string, data: any): Promise<T> => {
+        return this.withRetry(async () => {
+          const response = await fetchClient(url, {
+            method: 'PUT',
+            body: JSON.stringify(data)
+          })
+          return response.json()
+        })
+      },
+      
+      delete: async <T>(url: string): Promise<T> => {
+        return this.withRetry(async () => {
+          const response = await fetchClient(url, { method: 'DELETE' })
+          return response.json()
+        })
+      }
+    }
+  }
+
+  private async withRetry<T>(fn: () => Promise<T>): Promise<T> {
+    let lastError: Error
+    
+    for (let attempt = 1; attempt <= this.retries; attempt++) {
+      try {
+        return await fn()
+      } catch (error) {
+        lastError = error as Error
+        
+        if (attempt === this.retries) {
+          throw lastError
+        }
+        
+        // Exponential backoff
+        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
+        await new Promise(resolve => setTimeout(resolve, delay))
+      }
+    }
+    
+    throw lastError!
+  }
+
+  getConfig(): FluxStackConfig {
+    return this.config
+  }
+
+  getBaseUrl(): string {
+    return this.baseUrl
+  }
+}

package/core/framework/index.ts

@@ -0,0 +1,8 @@
+/**
+ * FluxStack Framework Core
+ * Main exports for the framework components
+ */
+
+export { FluxStackFramework } from "./server"
+export { FluxStackClient } from "./client"
+export * from "./types"