create-fluxstack 1.10.1 → 1.12.1

package/core/plugins/index.ts

@@ -1,204 +1,204 @@
-/**
- * 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?: 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
 } from './types'

package/core/plugins/manager.ts

@@ -18,11 +18,11 @@ import type {
 } from "./types"
 
 type Plugin = FluxStack.Plugin
-import type { FluxStackConfig } from "@/core/config/schema"
-import type { Logger } from "@/core/utils/logger"
+import type { FluxStackConfig } from "@config"
+import type { Logger } from "@core/utils/logger"
 import { PluginRegistry } from "./registry"
 import { createPluginUtils } from "./config"
-import { FluxStackError } from "@/core/utils/errors"
+import { FluxStackError } from "@core/utils/errors"
 import { EventEmitter } from "events"
 
 /**
@@ -402,20 +402,20 @@ 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 ?? []
+    const disabledNames = this.config.plugins.disabled ?? []
 
     return allPlugins.filter(plugin => {
       // If explicitly disabled, exclude
       if (disabledNames.includes(plugin.name)) {
         return false
       }
-      
+
       // If enabled list is empty, include all non-disabled
       if (enabledNames.length === 0) {
         return true
       }
-      
+
       // Otherwise, only include if explicitly enabled
       return enabledNames.includes(plugin.name)
     })
@@ -426,42 +426,30 @@ export class PluginManager extends EventEmitter {
    */
   private async discoverPlugins(): Promise<void> {
     try {
-      // Load built-in plugins first (handled by core system)
-      this.logger.debug('Loading built-in plugins...')
-      const builtInResults = await this.registry.discoverPlugins({
-        directories: [],
-        includeBuiltIn: true,
-        includeExternal: false
+      // ⚠️ 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[] = []
+
+      // 1. Discover project plugins (plugins/ directory)
+      this.logger.debug('Discovering project plugins in directory: plugins')
+      const projectResults = await this.registry.discoverPlugins({
+        directories: ['plugins'],
+        includeBuiltIn: false,
+        includeExternal: true
       })
+      results.push(...projectResults)
 
-      // Try to use auto-generated registry for external plugins (if available from build)
-      let externalResults: any[] = []
-      try {
-        // @ts-expect-error - auto-registry is generated during build, may not exist in dev
-        const autoRegistryModule = await import('./auto-registry')
-        if (autoRegistryModule.discoveredPlugins && autoRegistryModule.registerDiscoveredPlugins) {
-          this.logger.debug('🚀 Using auto-generated external plugins registry')
-          await autoRegistryModule.registerDiscoveredPlugins(this.registry)
-          externalResults = autoRegistryModule.discoveredPlugins.map((plugin: any) => ({
-            success: true,
-            plugin
-          }))
-        }
-      } catch (error) {
-        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: (error as Error).message })
-
-        // Fallback to runtime discovery for external plugins
-        this.logger.debug('Discovering external plugins in directory: plugins')
-        externalResults = await this.registry.discoverPlugins({
-          directories: ['plugins'],
-          includeBuiltIn: false,
-          includeExternal: true
-        })
+      // 2. Discover npm plugins (node_modules/)
+      if (this.config.plugins.discoverNpmPlugins) {
+        this.logger.debug('Discovering npm plugins in node_modules...')
+        const npmResults = await this.registry.discoverNpmPlugins()
+        results.push(...npmResults)
+      } else {
+        this.logger.debug('🔒 NPM plugin discovery disabled for security (PLUGINS_DISCOVER_NPM=false)')
+        this.logger.debug('   To enable: Set PLUGINS_DISCOVER_NPM=true and add plugins to PLUGINS_ALLOWED')
       }
 
-      // Combine results
-      const results = [...builtInResults, ...externalResults]
-
       let loaded = 0
       let failed = 0
 

package/core/plugins/module-resolver.ts

@@ -3,9 +3,9 @@
  * Implementa resolução em cascata: plugin local → projeto principal
  */
 
-import { existsSync } from 'fs'
+import { existsSync, readFileSync } from 'fs'
 import { join, resolve } from 'path'
-import type { Logger } from '@/core/utils/logger'
+import type { Logger } from '@core/utils/logger'
 
 export interface ModuleResolverConfig {
   projectRoot: string
@@ -15,6 +15,7 @@ export interface ModuleResolverConfig {
 export class PluginModuleResolver {
   private config: ModuleResolverConfig
   private logger?: Logger
+  private static readonly MAX_CACHE_SIZE = 1000
   private resolveCache: Map<string, string> = new Map()
 
   constructor(config: ModuleResolverConfig) {
@@ -22,6 +23,16 @@ export class PluginModuleResolver {
     this.logger = config.logger
   }
 
+  private cacheSet(key: string, value: string): void {
+    if (this.resolveCache.size >= PluginModuleResolver.MAX_CACHE_SIZE) {
+      const firstKey = this.resolveCache.keys().next().value
+      if (firstKey !== undefined) {
+        this.resolveCache.delete(firstKey)
+      }
+    }
+    this.cacheSet(key, value)
+  }
+
   /**
    * Resolve um módulo com estratégia em cascata:
    * 1. node_modules local do plugin
@@ -41,7 +52,7 @@ export class PluginModuleResolver {
     const localPath = this.tryResolveLocal(moduleName, pluginPath)
     if (localPath) {
       this.logger?.debug(`✅ Módulo '${moduleName}' encontrado localmente: ${localPath}`)
-      this.resolveCache.set(cacheKey, localPath)
+      this.cacheSet(cacheKey, localPath)
       return localPath
     }
 
@@ -49,7 +60,7 @@ export class PluginModuleResolver {
     const projectPath = this.tryResolveProject(moduleName)
     if (projectPath) {
       this.logger?.debug(`✅ Módulo '${moduleName}' encontrado no projeto: ${projectPath}`)
-      this.resolveCache.set(cacheKey, projectPath)
+      this.cacheSet(cacheKey, projectPath)
       return projectPath
     }
 
@@ -69,7 +80,7 @@ export class PluginModuleResolver {
       const packageJsonPath = join(localNodeModules, 'package.json')
       if (existsSync(packageJsonPath)) {
         try {
-          const pkg = require(packageJsonPath)
+          const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
           const entry = pkg.module || pkg.main || 'index.js'
           const entryPath = join(localNodeModules, entry)
 
@@ -105,7 +116,7 @@ export class PluginModuleResolver {
       const packageJsonPath = join(projectNodeModules, 'package.json')
       if (existsSync(packageJsonPath)) {
         try {
-          const pkg = require(packageJsonPath)
+          const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
           const entry = pkg.module || pkg.main || 'index.js'
           const entryPath = join(projectNodeModules, entry)
 
@@ -152,7 +163,7 @@ export class PluginModuleResolver {
       const resolvedLocal = this.findFileWithExtension(localPath)
       if (resolvedLocal) {
         this.logger?.debug(`✅ Subpath '${fullModule}' encontrado localmente: ${resolvedLocal}`)
-        this.resolveCache.set(cacheKey, resolvedLocal)
+        this.cacheSet(cacheKey, resolvedLocal)
         return resolvedLocal
       }
     }
@@ -164,7 +175,7 @@ export class PluginModuleResolver {
       const resolvedProject = this.findFileWithExtension(projectPath)
       if (resolvedProject) {
         this.logger?.debug(`✅ Subpath '${fullModule}' encontrado no projeto: ${resolvedProject}`)
-        this.resolveCache.set(cacheKey, resolvedProject)
+        this.cacheSet(cacheKey, resolvedProject)
         return resolvedProject
       }
     }