create-fluxstack 1.15.0 → 1.17.0

package/core/plugins/registry.ts

@@ -1,6 +1,20 @@
-import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
+import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions, PluginPriority } from "./types"
 
 type FluxStackPlugin = FluxStack.Plugin
+
+const PRIORITY_MAP: Record<string, number> = {
+  highest: 1000,
+  high: 750,
+  normal: 500,
+  low: 250,
+  lowest: 0
+}
+
+function normalizePriority(priority?: number | PluginPriority): number {
+  if (typeof priority === 'number') return priority
+  if (typeof priority === 'string' && priority in PRIORITY_MAP) return PRIORITY_MAP[priority]
+  return 500 // default to normal
+}
 import type { FluxStackConfig } from "@config"
 import type { Logger } from "@core/utils/logger"
 import { FluxStackError } from "@core/utils/errors"
@@ -223,6 +237,56 @@ export class PluginRegistry {
     return this.plugins.has(name)
   }
 
+  /**
+   * Register a plugin synchronously (no async hooks).
+   *
+   * Used by the framework to add plugins via .use() and during automatic
+   * plugin discovery, where the full async register() flow (which fires
+   * onPluginRegister hooks) is not needed — setup hooks run later in start().
+   */
+  registerSync(plugin: FluxStackPlugin): void {
+    if (this.plugins.has(plugin.name)) {
+      throw new FluxStackError(
+        `Plugin '${plugin.name}' is already registered`,
+        'PLUGIN_ALREADY_REGISTERED',
+        400
+      )
+    }
+
+    this.validatePlugin(plugin)
+    this.plugins.set(plugin.name, plugin)
+
+    if (plugin.dependencies) {
+      this.dependencies.set(plugin.name, plugin.dependencies)
+    }
+
+    this.updateLoadOrder()
+  }
+
+  /**
+   * Refresh the load order.
+   *
+   * Falls back to insertion-order if the topological sort fails
+   * (e.g. unresolvable external dependency listed but not yet registered).
+   */
+  refreshLoadOrder(): void {
+    try {
+      this.updateLoadOrder()
+    } catch {
+      this.loadOrder = Array.from(this.plugins.keys())
+    }
+  }
+
+  /**
+   * Return a read-only snapshot of the internal plugin map.
+   *
+   * Allows the framework to iterate over registered plugins for dependency
+   * validation without reaching into private fields.
+   */
+  getPluginsMap(): ReadonlyMap<string, FluxStackPlugin> {
+    return this.plugins
+  }
+
   /**
    * Check which dependencies are missing from main package.json
    */
@@ -278,12 +342,12 @@ export class PluginRegistry {
       return true
     }
 
-    if (allowedPlugins.length === 0) {
+    if ((allowedPlugins as string[]).length === 0) {
       this.logger?.warn(`NPM plugin '${pluginName}' blocked: No plugins in whitelist (PLUGINS_ALLOWED is empty)`)
       return false
     }
 
-    if (!allowedPlugins.includes(pluginName)) {
+    if (!(allowedPlugins as string[]).includes(pluginName)) {
       this.logger?.warn(`NPM plugin '${pluginName}' blocked: Not in whitelist (PLUGINS_ALLOWED)`, {
         pluginName,
         allowedPlugins
@@ -299,8 +363,8 @@ export class PluginRegistry {
   getStats() {
     return {
       totalPlugins: this.plugins.size,
-      enabledPlugins: this.config?.plugins.enabled?.length ?? 0,
-      disabledPlugins: this.config?.plugins.disabled?.length ?? 0,
+      enabledPlugins: (this.config?.plugins.enabled as string[] | undefined)?.length ?? 0,
+      disabledPlugins: (this.config?.plugins.disabled as string[] | undefined)?.length ?? 0,
       conflicts: this.conflicts.length,
       loadOrder: this.loadOrder.length
     }
@@ -644,9 +708,11 @@ export class PluginRegistry {
       )
     }
 
-    if (plugin.priority && typeof plugin.priority !== 'number') {
+    if (plugin.priority !== undefined
+      && typeof plugin.priority !== 'number'
+      && !(typeof plugin.priority === 'string' && plugin.priority in PRIORITY_MAP)) {
       throw new FluxStackError(
-        'Plugin priority must be a number',
+        `Plugin priority must be a number or one of: ${Object.keys(PRIORITY_MAP).join(', ')}`,
         'INVALID_PLUGIN_STRUCTURE',
         400
       )
@@ -656,7 +722,7 @@ export class PluginRegistry {
   /**
    * Validate plugin configuration against schema
    */
-  private validatePluginConfig(plugin: FluxStackPlugin, config: any): void {
+  private validatePluginConfig(plugin: FluxStackPlugin, config: unknown): void {
     if (!plugin.configSchema) {
       return
     }
@@ -664,7 +730,7 @@ export class PluginRegistry {
     // Basic validation - in a real implementation, you'd use a proper JSON schema validator
     if (plugin.configSchema.required) {
       for (const requiredField of plugin.configSchema.required) {
-        if (!(requiredField in config)) {
+        if (!(requiredField in (config as Record<string, unknown>))) {
           throw new FluxStackError(
             `Plugin '${plugin.name}' configuration missing required field: ${requiredField}`,
             'INVALID_PLUGIN_CONFIG',
@@ -741,9 +807,7 @@ export class PluginRegistry {
       ready.sort((a, b) => {
         const pluginA = this.plugins.get(a)
         const pluginB = this.plugins.get(b)
-        const priorityA = typeof pluginA?.priority === 'number' ? pluginA.priority : 0
-        const priorityB = typeof pluginB?.priority === 'number' ? pluginB.priority : 0
-        return priorityB - priorityA
+        return normalizePriority(pluginB?.priority) - normalizePriority(pluginA?.priority)
       })
 
       for (const name of ready) {

package/core/plugins/types.ts

@@ -36,9 +36,9 @@ export type PluginPriority = 'highest' | 'high' | 'normal' | 'low' | 'lowest' |
 export interface PluginContext {
   config: FluxStackConfig
   logger: Logger
-  app: any // Elysia app
+  app: unknown // Elysia app
   utils: PluginUtils
-  registry?: any // Plugin registry reference
+  registry?: unknown // Plugin registry reference
 }
 
 export interface PluginUtils {
@@ -49,8 +49,8 @@ export interface PluginUtils {
   isDevelopment: () => boolean
   getEnvironment: () => string
   createHash: (data: string) => string
-  deepMerge: (target: any, source: any) => any
-  validateSchema: (data: any, schema: any) => { valid: boolean; errors: string[] }
+  deepMerge: (target: Record<string, unknown>, source: Record<string, unknown>) => Record<string, unknown>
+  validateSchema: (data: Record<string, unknown>, schema: PluginConfigSchema) => { valid: boolean; errors: string[] }
 }
 
 export interface RequestContext {
@@ -60,8 +60,8 @@ export interface RequestContext {
   headers: Record<string, string>
   query: Record<string, string>
   params: Record<string, string>
-  body?: any
-  user?: any
+  body?: unknown
+  user?: unknown
   startTime: number
   handled?: boolean
   response?: Response
@@ -127,12 +127,12 @@ export interface PluginEventContext {
   pluginName: string
   pluginVersion?: string
   timestamp: number
-  data?: any
+  data?: unknown
 }
 
 export interface PluginConfigSchema {
   type: 'object'
-  properties: Record<string, any>
+  properties: Record<string, unknown>
   required?: string[]
   additionalProperties?: boolean
 }
@@ -203,7 +203,7 @@ export namespace FluxStack {
    * This property will be removed in a future major version.
    * Use the config/ folder structure for automatic type inference.
    */
-  defaultConfig?: any
+  defaultConfig?: unknown
 
   // CLI commands
   commands?: CliCommand[]
@@ -252,7 +252,7 @@ export interface PluginHookResult {
   duration: number
   plugin: string
   hook: PluginHook
-  context?: any
+  context?: unknown
 }
 
 export interface PluginMetrics {
@@ -319,7 +319,7 @@ export interface CliArgument {
   description: string
   required?: boolean
   type?: 'string' | 'number' | 'boolean'
-  default?: any
+  default?: unknown
   choices?: string[]
 }
 
@@ -328,7 +328,7 @@ export interface CliOption {
   short?: string
   description: string
   type?: 'string' | 'number' | 'boolean' | 'array'
-  default?: any
+  default?: unknown
   required?: boolean
   choices?: string[]
 }
@@ -343,7 +343,7 @@ export interface CliCommand {
   aliases?: string[]
   category?: string
   hidden?: boolean
-  handler: (args: any[], options: any, context: CliContext) => Promise<void> | void
+  handler: (args: unknown[], options: Record<string, unknown>, context: CliContext) => Promise<void> | void
 }
 
 export interface CliContext {
@@ -369,7 +369,7 @@ export interface ActiveUpload {
   fileType?: string
   fileSize?: number
   totalChunks: number
-  receivedChunks: Map<number, any>
+  receivedChunks: Map<number, unknown>
   startTime: number
   lastChunkTime?: number
 }

package/core/server/framework.ts

@@ -1,189 +1,3 @@
-import { Elysia } from "elysia"
-import { createHash as nodeCreateHash } from "crypto"
-import type { FluxStackConfig, FluxStackContext, Plugin } from "../types"
-import type { PluginContext, PluginUtils } from "../plugins/types"
-import { PluginManager } from "../plugins/manager"
-import { fluxStackConfig } from "@config"
-import { getEnvironmentInfo } from "../config"
-import { logger, type Logger } from "../utils/logger/index"
-import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
-
-export class FluxStackFramework {
-  private app: Elysia
-  private context: FluxStackContext
-  private pluginContext: PluginContext
-  private plugins: Plugin[] = []
-  private pluginManager: PluginManager
-  private initialized = false
-
-  constructor(config?: Partial<FluxStackConfig>) {
-    // Load the full configuration
-    const fullConfig = config ? { ...fluxStackConfig, ...config } : fluxStackConfig
-    const envInfo = getEnvironmentInfo()
-
-    this.context = {
-      config: fullConfig,
-      isDevelopment: envInfo.isDevelopment,
-      isProduction: envInfo.isProduction,
-      isTest: envInfo.isTest,
-      environment: envInfo.name
-    }
-
-    this.app = new Elysia()
-
-    // Create plugin utilities
-    const pluginUtils: PluginUtils = {
-      createTimer,
-      formatBytes,
-      isProduction,
-      isDevelopment,
-      getEnvironment: () => envInfo.name,
-      createHash: (data: string) => nodeCreateHash('sha256').update(data).digest('hex'),
-      deepMerge: (target: any, source: any) => {
-        const result = { ...target }
-        for (const key in source) {
-          if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
-            result[key] = pluginUtils.deepMerge(result[key] || {}, source[key])
-          } else {
-            result[key] = source[key]
-          }
-        }
-        return result
-      },
-      validateSchema: (_data: any, _schema: any) => {
-        // Simple validation - in a real implementation you'd use a proper schema validator
-        try {
-          // Basic validation logic
-          return { valid: true, errors: [] }
-        } catch (error) {
-          return { valid: false, errors: [error instanceof Error ? error.message : 'Validation failed'] }
-        }
-      }
-    }
-
-    // Create plugin context
-    this.pluginContext = {
-      config: fullConfig,
-      logger: logger as any,
-      app: this.app,
-      utils: pluginUtils
-    }
-
-    // Initialize plugin manager
-    this.pluginManager = new PluginManager({
-      config: fullConfig,
-      logger: logger as any,
-      app: this.app
-    })
-
-    this.setupCors()
-  }
-
-  private setupCors() {
-    const cors = this.context.config.cors
-
-    const allowedOrigins = cors.origins.length > 0 ? cors.origins : ['*']
-    const allowAllMethods = cors.methods.length > 0 ? cors.methods.join(", ") : "GET,POST,PUT,DELETE,OPTIONS"
-    const allowAllHeaders = cors.headers.length > 0 ? cors.headers.join(", ") : "Content-Type, Authorization"
-
-    const resolveOrigin = (requestOrigin?: string | null) => {
-      const origin = requestOrigin || allowedOrigins[0] || "*"
-      if (allowedOrigins.includes("*")) {
-        return cors.credentials ? origin : "*"
-      }
-      return allowedOrigins.includes(origin) ? origin : allowedOrigins[0] || origin
-    }
-
-    this.app
-      .onRequest(({ request, set }) => {
-        const origin = resolveOrigin(request.headers.get("origin"))
-        set.headers["Access-Control-Allow-Origin"] = origin
-        set.headers["Access-Control-Allow-Methods"] = allowAllMethods
-        set.headers["Access-Control-Allow-Headers"] = allowAllHeaders
-        set.headers["Vary"] = "Origin"
-        if (cors.credentials) {
-          set.headers["Access-Control-Allow-Credentials"] = "true"
-        }
-        if (cors.maxAge) {
-          set.headers["Access-Control-Max-Age"] = cors.maxAge.toString()
-        }
-      })
-      .options("*", ({ request, set }) => {
-        set.status = 204
-        const origin = resolveOrigin(request.headers.get("origin"))
-        set.headers["Access-Control-Allow-Origin"] = origin
-        set.headers["Access-Control-Allow-Methods"] = allowAllMethods
-        set.headers["Access-Control-Allow-Headers"] = allowAllHeaders
-        set.headers["Vary"] = "Origin"
-        if (cors.credentials) {
-          set.headers["Access-Control-Allow-Credentials"] = "true"
-        }
-        if (cors.maxAge) {
-          set.headers["Access-Control-Max-Age"] = cors.maxAge.toString()
-        }
-        return ""
-      })
-  }
-
-  use(plugin: Plugin) {
-    this.plugins.push(plugin)
-    if (plugin.setup) {
-      plugin.setup(this.pluginContext)
-    }
-    return this
-  }
-
-  routes(routeModule: any) {
-    this.app.use(routeModule)
-    return this
-  }
-
-  getApp() {
-    return this.app
-  }
-
-  getContext() {
-    return this.context
-  }
-
-  async listen(callback?: () => void) {
-    // Initialize plugins synchronously before starting server
-    if (!this.initialized) {
-      logger.debug('[FluxStack] Initializing automatic plugin discovery...')
-
-      try {
-        await this.pluginManager.initialize()
-        const stats = this.pluginManager.getRegistry().getStats()
-
-        logger.info('[FluxStack] Automatic plugins loaded successfully', {
-          pluginCount: stats.totalPlugins,
-          enabledPlugins: stats.enabledPlugins,
-          disabledPlugins: stats.disabledPlugins
-        })
-
-        this.initialized = true
-      } catch (error) {
-        logger.error('[FluxStack] Failed to initialize automatic plugins', { error })
-        throw error
-      }
-    }
-
-    const port = this.context.config.server.port
-    const apiPrefix = this.context.config.server.apiPrefix
-
-    this.app.listen(port, () => {
-      logger.info('[FluxStack] Server started on port ' + port, {
-        apiPrefix,
-        environment: this.context.environment,
-        manualPlugins: this.plugins.length,
-        automaticPlugins: this.pluginManager.getRegistry().getStats().totalPlugins
-      })
-      console.log(`🚀 API ready at http://localhost:${port}${apiPrefix}`)
-      console.log(`📋 Health check: http://localhost:${port}${apiPrefix}/health`)
-      console.log()
-      callback?.()
-    })
-
-    return this
-  }
-}
+// Re-export from canonical location to maintain backwards compatibility
+// The single source of truth is core/framework/server.ts
+export { FluxStackFramework } from "../framework/server"

package/core/server/live/auto-generated-components.ts

@@ -1,50 +1,26 @@
-// 🔥 Auto-generated Live Components Registration
-// This file is automatically generated during build time - DO NOT EDIT MANUALLY
-// Generated at: 2026-03-01T19:00:29.650Z
+// Auto-generated Live Components Registration
+// Generated by @fluxstack/live — DO NOT EDIT MANUALLY
+// Generated at: 2026-03-21T23:18:32.007Z
 
 import { LiveAdminPanel } from "@app/server/live/LiveAdminPanel"
-import { LiveChat } from "@app/server/live/LiveChat"
 import { LiveCounter } from "@app/server/live/LiveCounter"
 import { LiveForm } from "@app/server/live/LiveForm"
 import { LiveLocalCounter } from "@app/server/live/LiveLocalCounter"
+import { LivePingPong } from "@app/server/live/LivePingPong"
 import { LiveProtectedChat } from "@app/server/live/LiveProtectedChat"
 import { LiveRoomChat } from "@app/server/live/LiveRoomChat"
-import { LiveTodoList } from "@app/server/live/LiveTodoList"
+import { LiveSharedCounter } from "@app/server/live/LiveSharedCounter"
 import { LiveUpload } from "@app/server/live/LiveUpload"
-import { componentRegistry } from "@core/server/live"
 
-// Register all components statically for production bundle
-function registerAllComponents() {
-  try {
-    // Auto-generated component registrations
-    componentRegistry.registerComponentClass('LiveAdminPanel', LiveAdminPanel)
-    componentRegistry.registerComponentClass('LiveChat', LiveChat)
-    componentRegistry.registerComponentClass('LiveCounter', LiveCounter)
-    componentRegistry.registerComponentClass('LiveForm', LiveForm)
-    componentRegistry.registerComponentClass('LiveLocalCounter', LiveLocalCounter)
-    componentRegistry.registerComponentClass('LiveProtectedChat', LiveProtectedChat)
-    componentRegistry.registerComponentClass('LiveRoomChat', LiveRoomChat)
-    componentRegistry.registerComponentClass('LiveTodoList', LiveTodoList)
-    componentRegistry.registerComponentClass('LiveUpload', LiveUpload)
-    
-    console.log('📝 Live components registered successfully! (9 components)')
-  } catch (error) {
-    console.warn('⚠️ Error registering components:', error)
-  }
-}
-
-// Auto-register components
-registerAllComponents()
-
-// Export all components to ensure they're included in the bundle
-export { 
+// Component classes array for LiveServer({ components }) option
+export const liveComponentClasses = [
   LiveAdminPanel,
-  LiveChat,
   LiveCounter,
   LiveForm,
   LiveLocalCounter,
+  LivePingPong,
   LiveProtectedChat,
   LiveRoomChat,
-  LiveTodoList,
-  LiveUpload
-}
+  LiveSharedCounter,
+  LiveUpload,
+]

package/core/server/live/index.ts

@@ -36,6 +36,25 @@ export type {
 // These lazily access the LiveServer instance created by the plugin
 import { liveServer, pendingAuthProviders } from './websocket-plugin'
 import type { LiveAuthProvider as _LiveAuthProvider } from '@fluxstack/live'
+import type { ComponentRegistry as _ComponentRegistry } from '@fluxstack/live'
+import type { WebSocketConnectionManager as _WebSocketConnectionManager } from '@fluxstack/live'
+import type { RoomStateManager as _RoomStateManager } from '@fluxstack/live'
+import type { LiveRoomManager as _LiveRoomManager } from '@fluxstack/live'
+import type { RoomEventBus as _RoomEventBus } from '@fluxstack/live'
+import type { FileUploadManager as _FileUploadManager } from '@fluxstack/live'
+import type { PerformanceMonitor as _PerformanceMonitor } from '@fluxstack/live'
+import type { StateSignatureManager as _StateSignatureManager } from '@fluxstack/live'
+import type { LiveAuthManager as _LiveAuthManager } from '@fluxstack/live'
+
+function requireLiveServer() {
+  if (!liveServer) {
+    throw new Error(
+      'LiveComponents plugin not initialized. ' +
+      'Ensure the live-components plugin is loaded before accessing Live singletons.'
+    )
+  }
+  return liveServer
+}
 
 /**
  * Backward-compatible liveAuthManager.
@@ -43,7 +62,7 @@ import type { LiveAuthProvider as _LiveAuthProvider } from '@fluxstack/live'
  * then delegates to liveServer.authManager once available.
  * @deprecated Access via liveServer.authManager instead
  */
-export const liveAuthManager = {
+export const liveAuthManager: Pick<_LiveAuthManager, 'authenticate' | 'hasProviders' | 'authorizeRoom' | 'authorizeAction' | 'authorizeComponent'> & { register: (provider: _LiveAuthProvider) => void } = {
   register(provider: _LiveAuthProvider) {
     if (liveServer) {
       liveServer.useAuth(provider)
@@ -51,54 +70,40 @@ export const liveAuthManager = {
       pendingAuthProviders.push(provider)
     }
   },
-  get authenticate() { return liveServer!.authManager.authenticate.bind(liveServer!.authManager) },
-  get hasProviders() { return liveServer!.authManager.hasProviders.bind(liveServer!.authManager) },
-  get authorizeRoom() { return liveServer!.authManager.authorizeRoom.bind(liveServer!.authManager) },
-  get authorizeAction() { return liveServer!.authManager.authorizeAction.bind(liveServer!.authManager) },
-  get authorizeComponent() { return liveServer!.authManager.authorizeComponent.bind(liveServer!.authManager) },
-} as any
+  get authenticate() { return requireLiveServer().authManager.authenticate.bind(requireLiveServer().authManager) },
+  get hasProviders() { return requireLiveServer().authManager.hasProviders.bind(requireLiveServer().authManager) },
+  get authorizeRoom() { return requireLiveServer().authManager.authorizeRoom.bind(requireLiveServer().authManager) },
+  get authorizeAction() { return requireLiveServer().authManager.authorizeAction.bind(requireLiveServer().authManager) },
+  get authorizeComponent() { return requireLiveServer().authManager.authorizeComponent.bind(requireLiveServer().authManager) },
+}
+
+/** Helper to create a typed lazy proxy that delegates to a LiveServer property */
+function createLazyProxy<T extends object>(accessor: () => T): T {
+  return new Proxy({} as T, {
+    get(_, prop) { return (accessor() as Record<string | symbol, unknown>)[prop] }
+  })
+}
 
 /** @deprecated Access via liveServer.registry instead */
-export const componentRegistry = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.registry as any)[prop] }
-})
+export const componentRegistry = createLazyProxy<_ComponentRegistry>(() => requireLiveServer().registry)
 
 /** @deprecated Access via liveServer.connectionManager instead */
-export const connectionManager = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.connectionManager as any)[prop] }
-})
+export const connectionManager = createLazyProxy<_WebSocketConnectionManager>(() => requireLiveServer().connectionManager)
 
 /** @deprecated Access via liveServer.roomManager instead */
-export const liveRoomManager = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.roomManager as any)[prop] }
-})
+export const liveRoomManager = createLazyProxy<_LiveRoomManager>(() => requireLiveServer().roomManager)
 
 /** @deprecated Access via liveServer.roomEvents instead */
-export const roomEvents = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.roomEvents as any)[prop] }
-})
+export const roomEvents = createLazyProxy<_RoomEventBus>(() => requireLiveServer().roomEvents)
 
 /** @deprecated Access via liveServer.fileUploadManager instead */
-export const fileUploadManager = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.fileUploadManager as any)[prop] }
-})
+export const fileUploadManager = createLazyProxy<_FileUploadManager>(() => requireLiveServer().fileUploadManager)
 
 /** @deprecated Access via liveServer.performanceMonitor instead */
-export const performanceMonitor = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.performanceMonitor as any)[prop] }
-})
+export const performanceMonitor = createLazyProxy<_PerformanceMonitor>(() => requireLiveServer().performanceMonitor)
 
 /** @deprecated Access via liveServer.stateSignature instead */
-export const stateSignature = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.stateSignature as any)[prop] }
-})
-
-/** @deprecated Access via liveServer.debugger instead */
-export const liveDebugger = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.debugger as any)[prop] }
-})
+export const stateSignature = createLazyProxy<_StateSignatureManager>(() => requireLiveServer().stateSignature)
 
 // Room state backward compat
-export const roomState = new Proxy({} as any, {
-  get(_, prop) { return (liveServer!.roomManager as any)[prop] }
-})
+export const roomState = createLazyProxy<_LiveRoomManager>(() => requireLiveServer().roomManager)