create-fluxstack 1.16.0 → 1.17.1

package/core/plugins/index.ts

@@ -1,204 +1,207 @@
-/**
- * Enhanced Plugin System
- * Comprehensive plugin system with lifecycle hooks, dependency management, and configuration
- */
-
-// Core plugin types and interfaces
-export type {
-    FluxStack,
-    PluginContext,
-    PluginHook,
-    PluginPriority,
-    PluginManifest,
-    PluginLoadResult,
-    PluginRegistryState,
-    PluginHookResult,
-    PluginMetrics,
-    PluginDiscoveryOptions,
-    PluginInstallOptions,
-    PluginExecutionContext,
-    PluginValidationResult,
-    HookExecutionOptions,
-    PluginLifecycleEvent,
-    PluginConfigSchema,
-    RequestContext,
-    ResponseContext,
-    ErrorContext,
-    BuildContext
-} from './types'
-
-export type Plugin = FluxStack.Plugin
-
-// Plugin registry
-export { PluginRegistry } from './registry'
-export type { PluginRegistryConfig } from './registry'
-
-// Plugin discovery
-export { PluginDiscovery, pluginDiscovery } from './discovery'
-export type { PluginDiscoveryConfig } from './discovery'
-
-// Plugin configuration management
-export {
-    DefaultPluginConfigManager,
-    createPluginUtils
-} from './config'
-export type { PluginConfigManager } from './config'
-
-// Plugin manager
-export {
-    PluginManager,
-    createRequestContext,
-    createResponseContext,
-    createErrorContext,
-    createBuildContext
-} from './manager'
-export type { PluginManagerConfig } from './manager'
-
-// Module resolver for plugins
-export { PluginModuleResolver } from './module-resolver'
-export type { ModuleResolverConfig } from './module-resolver'
-
-// Plugin executor
-export {
-    PluginExecutor,
-    calculateExecutionStats
-} from './executor'
-export type {
-    PluginExecutionPlan,
-    PluginExecutionStep,
-    PluginExecutionStats
-} from './executor'
-
-// Utility functions for plugin development
-export const PluginUtils = {
-    /**
-     * Create a simple plugin
-     */
-    createPlugin: (config: {
-        name: string
-        version?: string
-        description?: string
-        dependencies?: string[]
-        priority?: number | PluginPriority
-        setup?: (context: PluginContext) => void | Promise<void>
-        onServerStart?: (context: PluginContext) => void | Promise<void>
-        onServerStop?: (context: PluginContext) => void | Promise<void>
-        onRequest?: (context: RequestContext) => void | Promise<void>
-        onBeforeRoute?: (context: RequestContext) => void | Promise<void>
-        onResponse?: (context: ResponseContext) => void | Promise<void>
-        onError?: (context: ErrorContext) => void | Promise<void>
-        configSchema?: any
-        defaultConfig?: any
-    }): Plugin => {
-        const plugin = {
-            name: config.name,
-            ...(config.version && { version: config.version }),
-            ...(config.description && { description: config.description }),
-            ...(config.dependencies && { dependencies: config.dependencies }),
-            ...(config.priority !== undefined && { priority: config.priority }),
-            ...(config.setup && { setup: config.setup }),
-            ...(config.onServerStart && { onServerStart: config.onServerStart }),
-            ...(config.onServerStop && { onServerStop: config.onServerStop }),
-            ...(config.onRequest && { onRequest: config.onRequest }),
-            ...(config.onBeforeRoute && { onBeforeRoute: config.onBeforeRoute }),
-            ...(config.onResponse && { onResponse: config.onResponse }),
-            ...(config.onError && { onError: config.onError }),
-            ...(config.configSchema && { configSchema: config.configSchema }),
-            ...(config.defaultConfig && { defaultConfig: config.defaultConfig })
-        } as Plugin
-        return plugin
-    },
-
-    /**
-     * Create a plugin manifest
-     */
-    createManifest: (config: {
-        name: string
-        version: string
-        description: string
-        author: string
-        license: string
-        homepage?: string
-        repository?: string
-        keywords?: string[]
-        dependencies?: Record<string, string>
-        peerDependencies?: Record<string, string>
-        fluxstack: {
-            version: string
-            hooks: PluginHook[]
-            config?: any
-            category?: string
-            tags?: string[]
-        }
-    }): any => {
-        return {
-            name: config.name,
-            version: config.version || '1.0.0',
-            description: config.description,
-            author: config.author,
-            license: config.license,
-            homepage: config.homepage,
-            repository: config.repository,
-            keywords: config.keywords || [],
-            dependencies: config.dependencies || {},
-            peerDependencies: config.peerDependencies,
-            fluxstack: config.fluxstack
-        }
-    },
-
-    /**
-     * Validate plugin structure
-     */
-    validatePlugin: (plugin: any): plugin is Plugin => {
-        return (
-            plugin &&
-            typeof plugin === 'object' &&
-            typeof plugin.name === 'string' &&
-            plugin.name.length > 0
-        )
-    },
-
-    /**
-     * Check if plugin implements hook
-     */
-    implementsHook: (plugin: Plugin, hook: PluginHook): boolean => {
-        const hookFunction = (plugin as any)[hook]
-        return hookFunction && typeof hookFunction === 'function'
-    },
-
-    /**
-     * Get plugin hooks
-     */
-    getPluginHooks: (plugin: Plugin): PluginHook[] => {
-        const hooks: PluginHook[] = []
-        const possibleHooks: PluginHook[] = [
-            'setup',
-            'onServerStart',
-            'onServerStop',
-            'onRequest',
-            'onResponse',
-            'onError',
-            'onBuild',
-            'onBuildComplete'
-        ]
-
-        for (const hook of possibleHooks) {
-            if (PluginUtils.implementsHook(plugin, hook)) {
-                hooks.push(hook)
-            }
-        }
-
-        return hooks
-    }
-}
-
-// Re-export types for convenience
-import type {
-    PluginContext,
-    PluginHook,
-    PluginPriority,
-    RequestContext,
-    ResponseContext,
-    ErrorContext,
-    FluxStack
+/**
+ * Enhanced Plugin System
+ * Comprehensive plugin system with lifecycle hooks, dependency management, and configuration
+ */
+
+// Core plugin types and interfaces
+export type {
+    FluxStack,
+    PluginContext,
+    PluginHook,
+    PluginPriority,
+    PluginManifest,
+    PluginLoadResult,
+    PluginRegistryState,
+    PluginHookResult,
+    PluginMetrics,
+    PluginDiscoveryOptions,
+    PluginInstallOptions,
+    PluginExecutionContext,
+    PluginValidationResult,
+    HookExecutionOptions,
+    PluginLifecycleEvent,
+    PluginConfigSchema,
+    RequestContext,
+    ResponseContext,
+    ErrorContext,
+    BuildContext
+} from './types'
+
+export type Plugin = FluxStack.Plugin
+
+// Plugin registry
+export { PluginRegistry } from './registry'
+export type { PluginRegistryConfig } from './registry'
+
+// Plugin discovery
+export { PluginDiscovery, pluginDiscovery } from './discovery'
+export type { PluginDiscoveryConfig } from './discovery'
+
+// Plugin configuration management
+export {
+    DefaultPluginConfigManager,
+    createPluginUtils
+} from './config'
+export type { PluginConfigManager } from './config'
+
+// Plugin manager
+export {
+    PluginManager,
+    createRequestContext,
+    createResponseContext,
+    createErrorContext,
+    createBuildContext
+} from './manager'
+export type { PluginManagerConfig } from './manager'
+
+// Module resolver for plugins
+export { PluginModuleResolver } from './module-resolver'
+export type { ModuleResolverConfig } from './module-resolver'
+
+// Plugin executor
+export {
+    PluginExecutor,
+    calculateExecutionStats
+} from './executor'
+export type {
+    PluginExecutionPlan,
+    PluginExecutionStep,
+    PluginExecutionStats
+} from './executor'
+
+// Utility functions for plugin development
+export const PluginUtils = {
+    /**
+     * Create a simple plugin
+     */
+    createPlugin: (config: {
+        name: string
+        version?: string
+        description?: string
+        dependencies?: string[]
+        priority?: number | PluginPriority
+        setup?: (context: PluginContext) => void | Promise<void>
+        onServerStart?: (context: PluginContext) => void | Promise<void>
+        onServerStop?: (context: PluginContext) => void | Promise<void>
+        onRequest?: (context: RequestContext) => void | Promise<void>
+        onBeforeRoute?: (context: RequestContext) => void | Promise<void>
+        onResponse?: (context: ResponseContext) => void | Promise<void>
+        onError?: (context: ErrorContext) => void | Promise<void>
+        configSchema?: PluginConfigSchema
+        defaultConfig?: unknown
+    }): Plugin => {
+        const plugin = {
+            name: config.name,
+            ...(config.version && { version: config.version }),
+            ...(config.description && { description: config.description }),
+            ...(config.dependencies && { dependencies: config.dependencies }),
+            ...(config.priority !== undefined && { priority: config.priority }),
+            ...(config.setup && { setup: config.setup }),
+            ...(config.onServerStart && { onServerStart: config.onServerStart }),
+            ...(config.onServerStop && { onServerStop: config.onServerStop }),
+            ...(config.onRequest && { onRequest: config.onRequest }),
+            ...(config.onBeforeRoute && { onBeforeRoute: config.onBeforeRoute }),
+            ...(config.onResponse && { onResponse: config.onResponse }),
+            ...(config.onError && { onError: config.onError }),
+            ...(config.configSchema && { configSchema: config.configSchema }),
+            ...(config.defaultConfig !== undefined ? { defaultConfig: config.defaultConfig } : {})
+        } as Plugin
+        return plugin
+    },
+
+    /**
+     * Create a plugin manifest
+     */
+    createManifest: (config: {
+        name: string
+        version: string
+        description: string
+        author: string
+        license: string
+        homepage?: string
+        repository?: string
+        keywords?: string[]
+        dependencies?: Record<string, string>
+        peerDependencies?: Record<string, string>
+        fluxstack: {
+            version: string
+            hooks: PluginHook[]
+            config?: PluginConfigSchema
+            category?: string
+            tags?: string[]
+        }
+    }): PluginManifest => {
+        return {
+            name: config.name,
+            version: config.version || '1.0.0',
+            description: config.description,
+            author: config.author,
+            license: config.license,
+            homepage: config.homepage,
+            repository: config.repository,
+            keywords: config.keywords || [],
+            dependencies: config.dependencies || {},
+            peerDependencies: config.peerDependencies,
+            fluxstack: config.fluxstack
+        }
+    },
+
+    /**
+     * Validate plugin structure
+     */
+    validatePlugin: (plugin: unknown): plugin is Plugin => {
+        return (
+            !!plugin &&
+            typeof plugin === 'object' &&
+            'name' in plugin &&
+            typeof (plugin as Record<string, unknown>).name === 'string' &&
+            ((plugin as Record<string, unknown>).name as string).length > 0
+        )
+    },
+
+    /**
+     * Check if plugin implements hook
+     */
+    implementsHook: (plugin: Plugin, hook: PluginHook): boolean => {
+        const hookFunction = plugin[hook]
+        return !!hookFunction && typeof hookFunction === 'function'
+    },
+
+    /**
+     * Get plugin hooks
+     */
+    getPluginHooks: (plugin: Plugin): PluginHook[] => {
+        const hooks: PluginHook[] = []
+        const possibleHooks: PluginHook[] = [
+            'setup',
+            'onServerStart',
+            'onServerStop',
+            'onRequest',
+            'onResponse',
+            'onError',
+            'onBuild',
+            'onBuildComplete'
+        ]
+
+        for (const hook of possibleHooks) {
+            if (PluginUtils.implementsHook(plugin, hook)) {
+                hooks.push(hook)
+            }
+        }
+
+        return hooks
+    }
+}
+
+// Re-export types for convenience
+import type {
+    PluginContext,
+    PluginConfigSchema,
+    PluginHook,
+    PluginManifest,
+    PluginPriority,
+    RequestContext,
+    ResponseContext,
+    ErrorContext,
+    FluxStack
 } from './types'

package/core/plugins/manager.ts

@@ -3,11 +3,12 @@
  * Handles plugin lifecycle, execution, and context management
  */
 
-import type { 
+import type {
   FluxStack,
-  PluginContext, 
-  PluginHook, 
-  PluginHookResult, 
+  PluginContext,
+  PluginHook,
+  PluginHookResult,
+  PluginLoadResult,
   PluginMetrics,
   PluginExecutionContext,
   HookExecutionOptions,
@@ -43,14 +44,14 @@ function parseRequestURL(request: Request): URL {
 export interface PluginManagerConfig {
   config: FluxStackConfig
   logger: Logger
-  app?: any
+  app?: unknown
 }
 
 export class PluginManager extends EventEmitter {
   private registry: PluginRegistry
   private config: FluxStackConfig
   private logger: Logger
-  private app?: any
+  private app?: unknown
   private metrics: Map<string, PluginMetrics> = new Map()
   private contexts: Map<string, PluginContext> = new Map()
   private initialized = false
@@ -163,8 +164,8 @@ export class PluginManager extends EventEmitter {
    * Execute a hook on all plugins
    */
   async executeHook(
-    hook: PluginHook, 
-    context?: any, 
+    hook: PluginHook,
+    context?: unknown,
     options: HookExecutionOptions = {}
   ): Promise<PluginHookResult[]> {
     const {
@@ -259,7 +260,7 @@ export class PluginManager extends EventEmitter {
   async executePluginHook(
     plugin: Plugin,
     hook: PluginHook,
-    context?: any,
+    context?: unknown,
     options: { timeout?: number; retries?: number } = {}
   ): Promise<PluginHookResult> {
     const { timeout = 30000, retries = 0 } = options
@@ -305,25 +306,25 @@ export class PluginManager extends EventEmitter {
         })
 
         // Execute the hook with appropriate context
-        let hookPromise: Promise<any>
+        let hookPromise: Promise<unknown>
 
         switch (hook) {
           case 'setup':
           case 'onServerStart':
           case 'onServerStop':
-            hookPromise = Promise.resolve(hookFunction(pluginContext as any))
+            hookPromise = Promise.resolve((hookFunction as Function)(pluginContext))
             break
           case 'onRequest':
           case 'onResponse':
           case 'onError':
-            hookPromise = Promise.resolve(hookFunction(context as any))
+            hookPromise = Promise.resolve((hookFunction as Function)(context))
             break
           case 'onBuild':
           case 'onBuildComplete':
-            hookPromise = Promise.resolve(hookFunction(context as any))
+            hookPromise = Promise.resolve((hookFunction as Function)(context))
             break
           default:
-            hookPromise = Promise.resolve(hookFunction(context || pluginContext))
+            hookPromise = Promise.resolve((hookFunction as Function)(context || pluginContext))
         }
 
         // Race between hook execution and timeout
@@ -408,8 +409,8 @@ export class PluginManager extends EventEmitter {
    */
   private getEnabledPlugins(): Plugin[] {
     const allPlugins = this.registry.getAll()
-    const enabledNames = this.config.plugins.enabled ?? []
-    const disabledNames = this.config.plugins.disabled ?? []
+    const enabledNames = (this.config.plugins.enabled ?? []) as string[]
+    const disabledNames = (this.config.plugins.disabled ?? []) as string[]
 
     return allPlugins.filter(plugin => {
       // If explicitly disabled, exclude
@@ -435,7 +436,7 @@ export class PluginManager extends EventEmitter {
       // ⚠️ Built-in plugins are now registered manually via .use()
       // No auto-discovery for core/plugins/built-in - developer chooses which to use
 
-      const results: any[] = []
+      const results: PluginLoadResult[] = []
 
       // 1. Discover project plugins (plugins/ directory)
       this.logger.debug('Discovering project plugins in directory: plugins')
@@ -566,7 +567,7 @@ export class PluginManager extends EventEmitter {
 /**
  * Create request context from HTTP request
  */
-export function createRequestContext(request: Request, additionalData: any = {}): RequestContext {
+export function createRequestContext(request: Request, additionalData: Record<string, unknown> = {}): RequestContext {
   const url = parseRequestURL(request)
   
   return {
@@ -593,7 +594,7 @@ export function createRequestContext(request: Request, additionalData: any = {})
 export function createResponseContext(
   requestContext: RequestContext,
   response: Response,
-  additionalData: any = {}
+  additionalData: Record<string, unknown> = {}
 ): ResponseContext {
   return {
     ...requestContext,
@@ -611,7 +612,7 @@ export function createResponseContext(
 export function createErrorContext(
   requestContext: RequestContext,
   error: Error,
-  additionalData: any = {}
+  additionalData: Record<string, unknown> = {}
 ): ErrorContext {
   return {
     ...requestContext,