create-fluxstack 1.0.2 → 1.0.4

package/my-final-test/core/plugins/__tests__/registry.test.ts

@@ -0,0 +1,335 @@
+/**
+ * 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/my-final-test/core/plugins/built-in/index.ts

@@ -0,0 +1,142 @@
+/**
+ * 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/my-final-test/core/plugins/built-in/logger/index.ts

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