create-fluxstack 1.0.1 → 1.0.2

package/core/plugins/__tests__/registry.test.ts

@@ -1,335 +0,0 @@
-/**
- * Tests for Plugin Registry
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { PluginRegistry } from '../registry'
-import type { Plugin, PluginManifest } from '../types'
-import type { Logger } from '../../utils/logger/index'
-
-// Mock logger
-const mockLogger: Logger = {
-  debug: vi.fn(),
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  child: vi.fn(() => mockLogger),
-  time: vi.fn(),
-  timeEnd: vi.fn(),
-  request: vi.fn()
-}
-
-describe('PluginRegistry', () => {
-  let registry: PluginRegistry
-
-  beforeEach(() => {
-    registry = new PluginRegistry({ logger: mockLogger })
-    vi.clearAllMocks()
-  })
-
-  describe('Plugin Registration', () => {
-    it('should register a plugin successfully', async () => {
-      const plugin: Plugin = {
-        name: 'test-plugin',
-        version: '1.0.0'
-      }
-
-      await registry.register(plugin)
-      expect(registry.get('test-plugin')).toBe(plugin)
-      expect(registry.has('test-plugin')).toBe(true)
-    })
-
-    it('should register a plugin with manifest', async () => {
-      const plugin: Plugin = {
-        name: 'test-plugin',
-        version: '1.0.0'
-      }
-
-      const manifest: PluginManifest = {
-        name: 'test-plugin',
-        version: '1.0.0',
-        description: 'Test plugin',
-        author: 'Test Author',
-        license: 'MIT',
-        keywords: ['test'],
-        dependencies: {},
-        fluxstack: {
-          version: '1.0.0',
-          hooks: ['setup']
-        }
-      }
-
-      await registry.register(plugin, manifest)
-      expect(registry.getManifest('test-plugin')).toBe(manifest)
-    })
-
-    it('should throw error when registering duplicate plugin', async () => {
-      const plugin: Plugin = {
-        name: 'duplicate-plugin'
-      }
-
-      await registry.register(plugin)
-      await expect(registry.register(plugin)).rejects.toThrow("Plugin 'duplicate-plugin' is already registered")
-    })
-
-    it('should validate plugin structure', async () => {
-      const invalidPlugin = {
-        // Missing name property
-        version: '1.0.0'
-      } as Plugin
-
-      await expect(registry.register(invalidPlugin)).rejects.toThrow('Plugin must have a valid name property')
-    })
-
-    it('should unregister a plugin successfully', async () => {
-      const plugin: Plugin = {
-        name: 'removable-plugin'
-      }
-
-      await registry.register(plugin)
-      expect(registry.get('removable-plugin')).toBe(plugin)
-
-      registry.unregister('removable-plugin')
-      expect(registry.get('removable-plugin')).toBeUndefined()
-      expect(registry.has('removable-plugin')).toBe(false)
-    })
-
-    it('should throw error when unregistering non-existent plugin', () => {
-      expect(() => registry.unregister('non-existent')).toThrow("Plugin 'non-existent' is not registered")
-    })
-
-    it('should prevent unregistering plugin with dependents', async () => {
-      const pluginA: Plugin = { name: 'plugin-a' }
-      const pluginB: Plugin = { name: 'plugin-b', dependencies: ['plugin-a'] }
-
-      await registry.register(pluginA)
-      await registry.register(pluginB)
-
-      expect(() => registry.unregister('plugin-a')).toThrow(
-        "Cannot unregister plugin 'plugin-a' because it is required by: plugin-b"
-      )
-    })
-  })
-
-  describe('Plugin Retrieval', () => {
-    it('should get all registered plugins', async () => {
-      const plugin1: Plugin = { name: 'plugin-1' }
-      const plugin2: Plugin = { name: 'plugin-2' }
-
-      await registry.register(plugin1)
-      await registry.register(plugin2)
-
-      const allPlugins = registry.getAll()
-      expect(allPlugins).toHaveLength(2)
-      expect(allPlugins).toContain(plugin1)
-      expect(allPlugins).toContain(plugin2)
-    })
-
-    it('should return undefined for non-existent plugin', () => {
-      expect(registry.get('non-existent')).toBeUndefined()
-    })
-
-    it('should get plugin dependencies', async () => {
-      const plugin: Plugin = {
-        name: 'plugin-with-deps',
-        dependencies: ['dep1', 'dep2']
-      }
-
-      await registry.register(plugin)
-      expect(registry.getDependencies('plugin-with-deps')).toEqual(['dep1', 'dep2'])
-    })
-
-    it('should get plugin dependents', async () => {
-      const pluginA: Plugin = { name: 'plugin-a' }
-      const pluginB: Plugin = { name: 'plugin-b', dependencies: ['plugin-a'] }
-      const pluginC: Plugin = { name: 'plugin-c', dependencies: ['plugin-a'] }
-
-      await registry.register(pluginA)
-      await registry.register(pluginB)
-      await registry.register(pluginC)
-
-      const dependents = registry.getDependents('plugin-a')
-      expect(dependents).toContain('plugin-b')
-      expect(dependents).toContain('plugin-c')
-    })
-
-    it('should get registry statistics', async () => {
-      const plugin1: Plugin = { name: 'plugin-1' }
-      const plugin2: Plugin = { name: 'plugin-2' }
-
-      await registry.register(plugin1)
-      await registry.register(plugin2)
-
-      const stats = registry.getStats()
-      expect(stats.totalPlugins).toBe(2)
-      expect(stats.loadOrder).toBe(2)
-    })
-  })
-
-  describe('Dependency Management', () => {
-    it('should validate dependencies successfully', async () => {
-      const pluginA: Plugin = {
-        name: 'plugin-a'
-      }
-
-      const pluginB: Plugin = {
-        name: 'plugin-b',
-        dependencies: ['plugin-a']
-      }
-
-      await registry.register(pluginA)
-      await registry.register(pluginB)
-
-      expect(() => registry.validateDependencies()).not.toThrow()
-    })
-
-    it('should throw error for missing dependencies', async () => {
-      const pluginWithMissingDep: Plugin = {
-        name: 'plugin-with-missing-dep',
-        dependencies: ['non-existent-plugin']
-      }
-
-      await registry.register(pluginWithMissingDep)
-      expect(() => registry.validateDependencies()).toThrow(
-        "Plugin dependency validation failed"
-      )
-    })
-
-    it('should detect circular dependencies', async () => {
-      const pluginA: Plugin = {
-        name: 'plugin-a',
-        dependencies: ['plugin-b']
-      }
-
-      const pluginB: Plugin = {
-        name: 'plugin-b',
-        dependencies: ['plugin-a']
-      }
-
-      await registry.register(pluginA)
-      
-      await expect(registry.register(pluginB)).rejects.toThrow('Circular dependency detected')
-    })
-  })
-
-  describe('Load Order', () => {
-    it('should determine correct load order based on dependencies', async () => {
-      const pluginA: Plugin = {
-        name: 'plugin-a'
-      }
-
-      const pluginB: Plugin = {
-        name: 'plugin-b',
-        dependencies: ['plugin-a']
-      }
-
-      const pluginC: Plugin = {
-        name: 'plugin-c',
-        dependencies: ['plugin-b']
-      }
-
-      await registry.register(pluginA)
-      await registry.register(pluginB)
-      await registry.register(pluginC)
-
-      const loadOrder = registry.getLoadOrder()
-      
-      expect(loadOrder.indexOf('plugin-a')).toBeLessThan(loadOrder.indexOf('plugin-b'))
-      expect(loadOrder.indexOf('plugin-b')).toBeLessThan(loadOrder.indexOf('plugin-c'))
-    })
-
-    it('should respect plugin priorities', async () => {
-      const lowPriorityPlugin: Plugin = {
-        name: 'low-priority',
-        priority: 1
-      }
-
-      const highPriorityPlugin: Plugin = {
-        name: 'high-priority',
-        priority: 10
-      }
-
-      await registry.register(lowPriorityPlugin)
-      await registry.register(highPriorityPlugin)
-
-      const loadOrder = registry.getLoadOrder()
-      
-      expect(loadOrder.indexOf('high-priority')).toBeLessThan(loadOrder.indexOf('low-priority'))
-    })
-
-    it('should handle plugins without priorities', async () => {
-      const pluginWithoutPriority: Plugin = {
-        name: 'no-priority'
-      }
-
-      const pluginWithPriority: Plugin = {
-        name: 'with-priority',
-        priority: 5
-      }
-
-      await registry.register(pluginWithoutPriority)
-      await registry.register(pluginWithPriority)
-
-      const loadOrder = registry.getLoadOrder()
-      
-      expect(loadOrder.indexOf('with-priority')).toBeLessThan(loadOrder.indexOf('no-priority'))
-    })
-  })
-
-  describe('Plugin Discovery', () => {
-    it('should discover plugins from directories', async () => {
-      // This would require mocking the filesystem
-      // For now, just test that the method exists and returns an array
-      const results = await registry.discoverPlugins({
-        directories: ['non-existent-dir']
-      })
-      
-      expect(Array.isArray(results)).toBe(true)
-    })
-
-    it('should load plugin from path', async () => {
-      // This would require mocking the filesystem and import
-      // For now, just test that the method exists
-      const result = await registry.loadPlugin('non-existent-path')
-      
-      expect(result).toHaveProperty('success')
-      expect(result.success).toBe(false)
-      expect(result).toHaveProperty('error')
-    })
-  })
-
-  describe('Plugin Configuration', () => {
-    it('should validate plugin configuration', async () => {
-      const plugin: Plugin = {
-        name: 'config-plugin',
-        configSchema: {
-          type: 'object',
-          properties: {
-            apiKey: { type: 'string' }
-          },
-          required: ['apiKey']
-        }
-      }
-
-      const config = {
-        plugins: {
-          enabled: ['config-plugin'],
-          disabled: [],
-          config: {
-            'config-plugin': {
-              apiKey: 'test-key'
-            }
-          }
-        }
-      }
-
-      const registryWithConfig = new PluginRegistry({ 
-        logger: mockLogger,
-        config: config as any
-      })
-
-      await registryWithConfig.register(plugin)
-      expect(registryWithConfig.get('config-plugin')).toBe(plugin)
-    })
-  })
-})

package/core/plugins/built-in/index.ts

@@ -1,142 +0,0 @@
-/**
- * Built-in Plugins for FluxStack
- * Core plugins that provide essential functionality
- */
-
-// Import all built-in plugins
-import { loggerPlugin } from './logger'
-import { swaggerPlugin } from './swagger'
-import { vitePlugin } from './vite'
-import { staticPlugin } from './static'
-import { monitoringPlugin } from './monitoring'
-
-// Export individual plugins
-export { loggerPlugin } from './logger'
-export { swaggerPlugin } from './swagger'
-export { vitePlugin } from './vite'
-export { staticPlugin } from './static'
-export { monitoringPlugin } from './monitoring'
-
-// Export as a collection
-export const builtInPlugins = {
-  logger: loggerPlugin,
-  swagger: swaggerPlugin,
-  vite: vitePlugin,
-  static: staticPlugin,
-  monitoring: monitoringPlugin
-} as const
-
-// Export as an array for easy registration
-export const builtInPluginsList = [
-  loggerPlugin,
-  swaggerPlugin,
-  vitePlugin,
-  staticPlugin,
-  monitoringPlugin
-] as const
-
-// Plugin categories
-export const pluginCategories = {
-  core: [loggerPlugin, staticPlugin],
-  development: [vitePlugin],
-  documentation: [swaggerPlugin],
-  monitoring: [loggerPlugin, monitoringPlugin]
-} as const
-
-// Default plugin configuration
-export const defaultPluginConfig = {
-  logger: {
-    logRequests: true,
-    logResponses: true,
-    logErrors: true,
-    includeHeaders: false,
-    includeBody: false,
-    slowRequestThreshold: 1000
-  },
-  swagger: {
-    enabled: true,
-    path: '/swagger',
-    title: 'FluxStack API',
-    description: 'Modern full-stack TypeScript framework with type-safe API endpoints'
-  },
-  vite: {
-    enabled: true,
-    port: 5173,
-    host: 'localhost',
-    checkInterval: 2000,
-    maxRetries: 10,
-    timeout: 5000
-  },
-  static: {
-    enabled: true,
-    publicDir: 'public',
-    distDir: 'dist/client',
-    indexFile: 'index.html',
-    spa: {
-      enabled: true,
-      fallback: 'index.html'
-    }
-  },
-  monitoring: {
-    enabled: false, // Disabled by default to avoid overhead
-    httpMetrics: true,
-    systemMetrics: true,
-    customMetrics: true,
-    collectInterval: 5000,
-    retentionPeriod: 300000,
-    exporters: [
-      {
-        type: 'console',
-        interval: 30000,
-        enabled: false
-      }
-    ],
-    thresholds: {
-      responseTime: 1000,
-      errorRate: 0.05,
-      memoryUsage: 0.8,
-      cpuUsage: 0.8
-    }
-  }
-} as const
-
-/**
- * Get default plugins for a specific environment
- */
-export function getDefaultPlugins(environment: 'development' | 'production' | 'test' = 'development') {
-  const basePlugins = [loggerPlugin, staticPlugin]
-  
-  switch (environment) {
-    case 'development':
-      return [...basePlugins, vitePlugin, swaggerPlugin, monitoringPlugin]
-    case 'production':
-      return [...basePlugins, monitoringPlugin]
-    case 'test':
-      return [loggerPlugin] // Minimal plugins for testing
-    default:
-      return basePlugins
-  }
-}
-
-/**
- * Get plugin by name
- */
-export function getBuiltInPlugin(name: string) {
-  return builtInPlugins[name as keyof typeof builtInPlugins]
-}
-
-/**
- * Check if a plugin is built-in
- */
-export function isBuiltInPlugin(name: string): boolean {
-  return name in builtInPlugins
-}
-
-/**
- * Get plugins by category
- */
-export function getPluginsByCategory(category: keyof typeof pluginCategories) {
-  return pluginCategories[category] || []
-}
-
-export default builtInPlugins

package/core/plugins/built-in/logger/index.ts

@@ -1,180 +0,0 @@
-import type { Plugin, PluginContext, RequestContext, ResponseContext, ErrorContext } from "../../types"
-
-export const loggerPlugin: Plugin = {
-  name: "logger",
-  version: "1.0.0",
-  description: "Enhanced logging plugin for FluxStack with request/response logging",
-  author: "FluxStack Team",
-  priority: "highest", // Logger should run first
-  category: "core",
-  tags: ["logging", "monitoring"],
-  
-  configSchema: {
-    type: "object",
-    properties: {
-      logRequests: {
-        type: "boolean",
-        description: "Enable request logging"
-      },
-      logResponses: {
-        type: "boolean", 
-        description: "Enable response logging"
-      },
-      logErrors: {
-        type: "boolean",
-        description: "Enable error logging"
-      },
-      includeHeaders: {
-        type: "boolean",
-        description: "Include headers in request/response logs"
-      },
-      includeBody: {
-        type: "boolean",
-        description: "Include body in request/response logs"
-      },
-      slowRequestThreshold: {
-        type: "number",
-        minimum: 0,
-        description: "Threshold in ms to log slow requests"
-      }
-    },
-    additionalProperties: false
-  },
-  
-  defaultConfig: {
-    logRequests: process.env.ENABLE_REQUEST_LOGS === 'true',
-    logResponses: process.env.ENABLE_REQUEST_LOGS === 'true',
-    logErrors: true,
-    includeHeaders: false,
-    includeBody: false,
-    slowRequestThreshold: 1000
-  },
-
-  setup: async (context: PluginContext) => {
-    context.logger.info("Enhanced logger plugin initialized", {
-      environment: context.config.app?.name || 'fluxstack',
-      logLevel: context.config.logging.level,
-      format: context.config.logging.format
-    })
-  },
-
-  onServerStart: async (context: PluginContext) => {
-    context.logger.info("Logger plugin: Server started", {
-      port: context.config.server.port,
-      host: context.config.server.host,
-      apiPrefix: context.config.server.apiPrefix
-    })
-  },
-
-  onServerStop: async (context: PluginContext) => {
-    context.logger.info("Logger plugin: Server stopped")
-  },
-
-  onRequest: async (context: RequestContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.logRequests) return
-
-    const logData: any = {
-      method: context.method,
-      path: context.path,
-      userAgent: context.headers['user-agent'],
-      ip: context.headers['x-forwarded-for'] || context.headers['x-real-ip'] || 'unknown'
-    }
-
-    if (config.includeHeaders) {
-      logData.headers = context.headers
-    }
-
-    if (config.includeBody && context.body) {
-      logData.body = context.body
-    }
-
-    // Use a logger from context if available, otherwise create one
-    const logger = (context as any).logger || console
-    if (typeof logger.info === 'function') {
-      logger.info(`→ ${context.method} ${context.path}`, logData)
-    }
-  },
-
-  onResponse: async (context: ResponseContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.logResponses) return
-
-    const logData: any = {
-      method: context.method,
-      path: context.path,
-      statusCode: context.statusCode,
-      duration: context.duration,
-      size: context.size
-    }
-
-    if (config.includeHeaders) {
-      const headers: Record<string, string> = {}
-      context.response.headers.forEach((value, key) => {
-        headers[key] = value
-      })
-      logData.responseHeaders = headers
-    }
-
-    // Determine log level based on status code and duration
-    let logLevel = 'info'
-    if (context.statusCode >= 400) {
-      logLevel = 'warn'
-    }
-    if (context.statusCode >= 500) {
-      logLevel = 'error'
-    }
-    if (context.duration > config.slowRequestThreshold) {
-      logLevel = 'warn'
-    }
-
-    const logger = (context as any).logger || console
-    const logMessage = `← ${context.method} ${context.path} ${context.statusCode} ${context.duration}ms`
-    
-    if (typeof logger[logLevel] === 'function') {
-      logger[logLevel](logMessage, logData)
-    }
-  },
-
-  onError: async (context: ErrorContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.logErrors) return
-
-    // Skip logging for NOT_FOUND errors unless explicitly enabled
-    if (context.error.message === 'NOT_FOUND' && !process.env.ENABLE_NOT_FOUND_LOGS) {
-      return
-    }
-
-    const logData: any = {
-      method: context.method,
-      path: context.path,
-      duration: context.duration,
-      error: {
-        name: context.error.name,
-        message: context.error.message,
-        stack: context.error.stack
-      }
-    }
-
-    if (config.includeHeaders) {
-      logData.headers = context.headers
-    }
-
-    const logger = (context as any).logger || console
-    if (typeof logger.error === 'function') {
-      logger.error(`✗ ${context.method} ${context.path} - ${context.error.message}`, logData)
-    }
-  }
-}
-
-// Helper function to get plugin config from context
-function getPluginConfig(_context: any) {
-  // In a real implementation, this would get the config from the plugin context
-  // For now, return default config
-  return loggerPlugin.defaultConfig || {}
-}
-
-export default loggerPlugin