create-fluxstack 1.18.1 → 1.19.0

package/core/framework/server.ts

@@ -1,8 +1,7 @@
 import { Elysia, type AnyElysia } from "elysia"
 import type { FluxStackConfig, FluxStackContext } from "@core/types"
 import type { FluxStack, PluginContext, PluginUtils, PluginConfigSchema, PluginHook } from "@core/plugins/types"
-import { PluginRegistry } from "@core/plugins/registry"
-import { PluginManager } from "@core/plugins/manager"
+import { PluginRegistry, PluginManager } from "@fluxstack/plugin-kit"
 import { fluxStackConfig } from "@config"
 import { getEnvironmentInfo } from "@core/config"
 import { logger, type Logger } from "@core/utils/logger"
@@ -11,7 +10,7 @@ import { liveServer } from "@core/server/live"
 import { FluxStackError } from "@core/utils/errors"
 import { createTimer, formatBytes, isProduction, isDevelopment } from "@core/utils/helpers"
 import { createHash } from "crypto"
-import { createPluginUtils } from "@core/plugins/config"
+import { createPluginUtils } from "@fluxstack/plugin-kit"
 import { pluginClientHooks } from "@core/server/plugin-client-hooks"
 import type { Plugin } from "@core/plugins"
 
@@ -149,10 +148,19 @@ export class FluxStackFramework {
       }
     }
 
-    // Initialize plugin manager
-    this.pluginManager = new PluginManager({
+    // Initialize plugin manager.
+    // The plugin-kit's PluginManager requires `settings` (plugin-related
+    // config slice) and `clientHooks` (registry impl) to be passed
+    // explicitly — it no longer reaches into the full config or imports
+    // the client hooks singleton.
+    this.pluginManager = new PluginManager<FluxStackConfig>({
       config: fullConfig,
+      settings: fullConfig.plugins,
       logger: pluginLogger,
+      clientHooks: {
+        register: (hookName: string, jsCode: string) =>
+          pluginClientHooks.register(hookName, jsCode)
+      },
       app: this.app
     })
 
@@ -832,17 +840,23 @@ export class FluxStackFramework {
       const showBanner = this.cfg.server.showBanner !== false // default: true
       const vitePluginActive = this.pluginRegistry.has('vite')
 
-      // Prepare startup info for banner or callback
+      // Prepare startup info for banner or callback.
+      // `plugins` is sourced from the PluginRegistry (the single source
+      // of truth after the plugin-kit migration) — this includes every
+      // plugin registered via `.use()`, regardless of whether it
+      // bothered to push itself to `globalThis.__fluxstackPlugins`.
+      const registeredPlugins = this.pluginRegistry.getAll()
       const startupInfo: StartupInfo = {
         port,
         host: this.cfg.server.host || 'localhost',
         apiPrefix,
         environment: this.context.environment,
-        pluginCount: this.pluginRegistry.getAll().length,
+        pluginCount: registeredPlugins.length,
         vitePort: this.cfg.client?.port,
         viteEmbedded: vitePluginActive, // Vite is embedded when plugin is active
         swaggerPath: '/swagger', // TODO: Get from swagger plugin config
-        liveComponents: liveServer?.registry.getRegisteredComponentNames() ?? []
+        liveComponents: liveServer?.registry.getRegisteredComponentNames() ?? [],
+        plugins: registeredPlugins.map(p => ({ name: p.name })),
       }
 
       // Display banner if enabled

package/core/index.ts

@@ -22,11 +22,12 @@ export * from './build'
 // CLI and generators
 export * from './cli/generators'
 
-// Plugin system (avoid wildcard to prevent conflicts)
-export { PluginRegistry } from './plugins/registry'
-export { PluginDiscovery } from './plugins/discovery'
-export { PluginManager } from './plugins/manager'
-export { PluginUtils } from './plugins'
+// Plugin system (via @fluxstack/plugin-kit — single source of truth)
+export {
+  PluginRegistry,
+  PluginDiscovery,
+  PluginManager,
+} from '@fluxstack/plugin-kit'
 
 // Utilities (avoid wildcard export to prevent type duplication)
 export {

package/core/plugins/index.ts

@@ -1,207 +1,79 @@
 /**
- * Enhanced Plugin System
- * Comprehensive plugin system with lifecycle hooks, dependency management, and configuration
+ * Thin shim barrel over @fluxstack/plugin-kit.
+ *
+ * All plugin system types and runtime live in @fluxstack/plugin-kit
+ * now (see .ai-notes/plans/2026-04-11-plugin-kit-extraction.md).
+ * This barrel just re-exports them. The FluxStack-specialized type
+ * aliases (Plugin = Plugin<FluxStackConfig>, PluginContext =
+ * PluginContext<FluxStackConfig>, etc.) come from the local
+ * `./types` shim so legacy `import { Plugin } from '@core/plugins'`
+ * call sites stay typed against FluxStack's concrete config shape.
  */
 
-// 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 } from './discovery'
-export type { PluginDiscoveryConfig } from './discovery'
+// ─── Runtime + non-specialized types (from the lib) ──────────
 
-// Plugin configuration management
 export {
-    DefaultPluginConfigManager,
-    createPluginUtils
-} from './config'
-export type { PluginConfigManager } from './config'
+  PluginRegistry,
+  PluginDiscovery,
+  PluginManager,
+  PluginModuleResolver,
+  PluginExecutor,
+  calculateExecutionStats,
+  createPluginUtils,
+  createRequestContext,
+  createResponseContext,
+  createErrorContext,
+  createBuildContext,
+  PluginError,
+} from '@fluxstack/plugin-kit'
 
-// 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'
+  FluxStack,
+  PluginHook,
+  PluginPriority,
+  PluginManifest,
+  PluginHookResult,
+  PluginMetrics,
+  PluginDiscoveryOptions,
+  PluginInstallOptions,
+  PluginValidationResult,
+  HookExecutionOptions,
+  PluginLifecycleEvent,
+  PluginConfigSchema,
+  PluginRegistryConfig,
+  PluginRegistrySettings,
+  PluginDiscoveryConfig,
+  PluginManagerConfig,
+  ModuleResolverConfig,
+  PluginExecutionPlan,
+  PluginExecutionStep,
+  PluginExecutionStats,
+} from '@fluxstack/plugin-kit'
+
+// ─── FluxStack-specialized type aliases (from the local shim) ───
 
-// 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'
+export type {
+  Plugin,
+  PluginContext,
+  RequestContext,
+  ResponseContext,
+  ErrorContext,
+  RouteContext,
+  ValidationContext,
+  TransformContext,
+  BuildContext,
+  BuildAssetContext,
+  BuildErrorContext,
+  ConfigLoadContext,
+  PluginEventContext,
+  CliArgument,
+  CliOption,
+  CliCommand,
+  CliContext,
+  PluginLoadResult,
+  PluginRegistryState,
+  PluginExecutionContext,
+  PluginClientHooksAPI,
+  PluginUtils,
+  Logger,
+} from './types'