create-fluxstack 1.16.0 → 1.17.0

package/core/framework/server.ts

@@ -1,15 +1,17 @@
 import { Elysia } from "elysia"
 import type { FluxStackConfig, FluxStackContext } from "@core/types"
-import type { FluxStack, PluginContext, PluginUtils } from "@core/plugins/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 { fluxStackConfig } from "@config"
 import { getEnvironmentInfo } from "@core/config"
-import { logger } from "@core/utils/logger"
+import { logger, type Logger } from "@core/utils/logger"
 import { displayStartupBanner, type StartupInfo } from "@core/utils/logger/startup-banner"
 import { componentRegistry } 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 type { Plugin } from "@core/plugins"
 
 export class FluxStackFramework {
@@ -20,6 +22,12 @@ export class FluxStackFramework {
   private pluginContext: PluginContext
   private isStarted: boolean = false
   private requestTimings: Map<string, number> = new Map()
+  private _originalStderrWrite?: typeof process.stderr.write
+
+  /** Access typed config from context (config is stored as unknown to avoid circular deps) */
+  private get cfg(): import('@config').FluxStackConfig {
+    return this.context.config as import('@config').FluxStackConfig
+  }
 
   /**
    * Helper to safely parse request.url which might be relative or absolute
@@ -59,7 +67,8 @@ export class FluxStackFramework {
 
     // Fallback: try to get from Bun's server socket (if available)
     // This is set by Bun when running in server mode
-    const socketIP = (request as any).ip || (request as any).remoteAddress
+    const requestWithSocket = request as Request & { ip?: string; remoteAddress?: string }
+    const socketIP = requestWithSocket.ip || requestWithSocket.remoteAddress
     if (socketIP) {
       return socketIP
     }
@@ -96,58 +105,42 @@ export class FluxStackFramework {
       isDevelopment,
       getEnvironment: () => envInfo.name,
       createHash: (data: string) => {
-        const crypto = require('crypto')
-        return crypto.createHash('sha256').update(data).digest('hex')
+        return createHash('sha256').update(data).digest('hex')
       },
-      deepMerge: (target: any, source: any) => {
+      deepMerge: (target: Record<string, unknown>, source: Record<string, unknown>) => {
         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])
+            result[key] = pluginUtils.deepMerge(result[key] as Record<string, unknown> || {}, source[key] as Record<string, unknown>)
           } 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'] }
-        }
+      validateSchema: (data: Record<string, unknown>, schema: PluginConfigSchema) => {
+        return createPluginUtils(logger).validateSchema(data, schema)
       }
     }
 
-    // Create plugin-compatible logger interface
-    interface PluginLogger {
-      debug: (message: string, meta?: unknown) => void
-      info: (message: string, meta?: unknown) => void
-      warn: (message: string, meta?: unknown) => void
-      error: (message: string, meta?: unknown) => void
-      child: (context: Record<string, unknown>) => PluginLogger
-      time: (label: string) => void
-      timeEnd: (label: string) => void
-      request: (method: string, path: string, status?: number, duration?: number, ip?: string) => void
-    }
-
-    const pluginLogger: PluginLogger = {
-      debug: (message: string, meta?: unknown) => logger.debug(message, meta),
-      info: (message: string, meta?: unknown) => logger.info(message, meta),
-      warn: (message: string, meta?: unknown) => logger.warn(message, meta),
-      error: (message: string, meta?: unknown) => logger.error(message, meta),
-      child: (context: Record<string, unknown>) => pluginLogger,
+    // Create plugin-compatible logger
+    const pluginLogger: Logger = {
+      debug: (message: unknown, ...args: unknown[]) => logger.debug(message, ...args),
+      info: (message: unknown, ...args: unknown[]) => logger.info(message, ...args),
+      warn: (message: unknown, ...args: unknown[]) => logger.warn(message, ...args),
+      error: (message: unknown, ...args: unknown[]) => logger.error(message, ...args),
+      child: (_context: Record<string, unknown>) => pluginLogger,
       time: (label: string) => logger.time(label),
       timeEnd: (label: string) => logger.timeEnd(label),
       request: (method: string, path: string, status?: number, duration?: number, ip?: string) =>
-        logger.request(method, path, status, duration, ip)
+        logger.request(method, path, status, duration, ip),
+      plugin: (pluginName: string, message: string, meta?: unknown) => logger.plugin(pluginName, message, meta),
+      framework: (message: string, meta?: unknown) => logger.framework(message, meta)
     }
 
     this.pluginContext = {
       config: fullConfig,
-      logger: pluginLogger as any,
+      logger: pluginLogger,
       app: this.app,
       utils: pluginUtils
     }
@@ -155,7 +148,7 @@ export class FluxStackFramework {
     // Initialize plugin manager
     this.pluginManager = new PluginManager({
       config: fullConfig,
-      logger: pluginLogger as any,
+      logger: pluginLogger,
       app: this.app
     })
 
@@ -169,11 +162,6 @@ export class FluxStackFramework {
       environment: envInfo.name,
       port: fullConfig.server.port
     })
-
-    // Initialize automatic plugin discovery in background
-    this.initializeAutomaticPlugins().catch(error => {
-      logger.error('Failed to initialize automatic plugins', { error })
-    })
   }
 
   private async initializeAutomaticPlugins() {
@@ -184,27 +172,16 @@ export class FluxStackFramework {
       const discoveredPlugins = this.pluginManager.getRegistry().getAll()
       for (const plugin of discoveredPlugins) {
         if (!this.pluginRegistry.has(plugin.name)) {
-          // Register in main registry (synchronously, will call setup in start())
-          (this.pluginRegistry as any).plugins.set(plugin.name, plugin)
-          if (plugin.dependencies) {
-            (this.pluginRegistry as any).dependencies.set(plugin.name, plugin.dependencies)
-          }
+          this.pluginRegistry.registerSync(plugin)
         }
       }
 
-      // Update load order
-      try {
-        (this.pluginRegistry as any).updateLoadOrder()
-      } catch (error) {
-        // Fallback: create basic load order
-        const plugins = (this.pluginRegistry as any).plugins as Map<string, FluxStack.Plugin>
-        const loadOrder = Array.from(plugins.keys())
-        ;(this.pluginRegistry as any).loadOrder = loadOrder
-      }
+      // Refresh load order (falls back to insertion-order on failure)
+      this.pluginRegistry.refreshLoadOrder()
 
       // Execute onConfigLoad hooks for all plugins
       const configLoadContext = {
-        config: this.context.config,
+        config: this.context.config as import('@config').FluxStackConfig,
         envVars: process.env as Record<string, string | undefined>,
         configPath: undefined
       }
@@ -235,13 +212,13 @@ export class FluxStackFramework {
   }
 
   private setupCors() {
-    const cors = this.context.config.cors
+    const cors = this.cfg.cors
 
     this.app
       .onRequest(({ set }) => {
-        set.headers["Access-Control-Allow-Origin"] = cors.origins.join(", ") || "*"
-        set.headers["Access-Control-Allow-Methods"] = cors.methods.join(", ") || "*"
-        set.headers["Access-Control-Allow-Headers"] = cors.headers.join(", ") || "*"
+        set.headers["Access-Control-Allow-Origin"] = (cors.origins ?? []).join(", ") || "*"
+        set.headers["Access-Control-Allow-Methods"] = (cors.methods ?? []).join(", ") || "*"
+        set.headers["Access-Control-Allow-Headers"] = (cors.headers ?? []).join(", ") || "*"
         if (cors.credentials) {
           set.headers["Access-Control-Allow-Credentials"] = "true"
         }
@@ -258,7 +235,7 @@ export class FluxStackFramework {
       const url = this.parseRequestURL(request)
 
       // Handle API routes
-      if (url.pathname.startsWith(this.context.config.server.apiPrefix)) {
+      if (url.pathname.startsWith(this.cfg.server.apiPrefix)) {
         set.status = 200
         set.headers['Content-Type'] = 'application/json'
         set.headers['Content-Length'] = '0'
@@ -270,7 +247,6 @@ export class FluxStackFramework {
       if (isStatic) {
         set.status = 200
         set.headers['Content-Type'] = 'text/html'
-        set.headers['Content-Length'] = '478' // approximate size of index.html
         set.headers['Cache-Control'] = 'no-cache'
         return ""
       }
@@ -322,7 +298,7 @@ export class FluxStackFramework {
     }
 
       // Store reference to restore original behavior if needed
-      ; (this as any)._originalStderrWrite = originalStderrWrite
+      this._originalStderrWrite = originalStderrWrite
   }
 
   private setupHooks() {
@@ -431,7 +407,7 @@ export class FluxStackFramework {
         query: Object.fromEntries(url.searchParams.entries()),
         params: {},
         response: currentResponse,
-        statusCode: Number((currentResponse as any)?.status || set.status || 200),
+        statusCode: Number((currentResponse instanceof Response ? currentResponse.status : undefined) || set.status || 200),
         duration,
         startTime
       }
@@ -464,7 +440,7 @@ export class FluxStackFramework {
       }
 
       // Log the request automatically (if not disabled in config)
-      if (this.context.config.server.enableRequestLogging !== false) {
+      if (this.cfg.server.enableRequestLogging !== false) {
         // Ensure status is always a number (HTTP status code)
         const status = typeof responseContext.statusCode === 'number'
           ? responseContext.statusCode
@@ -533,17 +509,17 @@ export class FluxStackFramework {
     })
   }
 
-  private async executePluginHooks(hookName: string, context: any): Promise<void> {
+  private async executePluginHooks(hookName: PluginHook, context: unknown): Promise<void> {
     const loadOrder = this.pluginRegistry.getLoadOrder()
 
     for (const pluginName of loadOrder) {
       const plugin = this.pluginRegistry.get(pluginName)
       if (!plugin) continue
 
-      const hookFn = (plugin as any)[hookName]
+      const hookFn = plugin[hookName]
       if (typeof hookFn === 'function') {
         try {
-          await hookFn(context)
+          await (hookFn as Function)(context)
         } catch (error) {
           const err = error instanceof Error ? error : new Error(String(error))
           logger.error(`Plugin '${pluginName}' ${hookName} hook failed`, {
@@ -566,8 +542,8 @@ export class FluxStackFramework {
       const otherPlugin = this.pluginRegistry.get(otherPluginName)
       if (!otherPlugin) continue
 
-      const hookFn = (otherPlugin as any).onPluginError
-      if (typeof hookFn === 'function') {
+      const hookFn = otherPlugin.onPluginError
+      if (hookFn && typeof hookFn === 'function') {
         try {
           await hookFn({
             pluginName,
@@ -584,17 +560,17 @@ export class FluxStackFramework {
     }
   }
 
-  private async executePluginBeforeRouteHooks(requestContext: any): Promise<Response | null> {
+  private async executePluginBeforeRouteHooks(requestContext: { handled?: boolean; response?: Response; [key: string]: unknown }): Promise<Response | null> {
     const loadOrder = this.pluginRegistry.getLoadOrder()
 
     for (const pluginName of loadOrder) {
       const plugin = this.pluginRegistry.get(pluginName)
       if (!plugin) continue
 
-      const onBeforeRouteFn = (plugin as any).onBeforeRoute
-      if (typeof onBeforeRouteFn === 'function') {
+      const onBeforeRouteFn = plugin.onBeforeRoute
+      if (onBeforeRouteFn && typeof onBeforeRouteFn === 'function') {
         try {
-          await onBeforeRouteFn(requestContext)
+          await onBeforeRouteFn(requestContext as unknown as import('@core/plugins/types').RequestContext)
 
           // If this plugin handled the request, return the response
           if (requestContext.handled && requestContext.response) {
@@ -611,17 +587,17 @@ export class FluxStackFramework {
     return null
   }
 
-  private async executePluginErrorHooks(errorContext: any): Promise<Response | null> {
+  private async executePluginErrorHooks(errorContext: { handled?: boolean; error: Error; request: Request; [key: string]: unknown }): Promise<Response | null> {
     const loadOrder = this.pluginRegistry.getLoadOrder()
 
     for (const pluginName of loadOrder) {
       const plugin = this.pluginRegistry.get(pluginName)
       if (!plugin) continue
 
-      const onErrorFn = (plugin as any).onError
-      if (typeof onErrorFn === 'function') {
+      const onErrorFn = plugin.onError
+      if (onErrorFn && typeof onErrorFn === 'function') {
         try {
-          await onErrorFn(errorContext)
+          await onErrorFn(errorContext as unknown as import('@core/plugins/types').ErrorContext)
 
           // If this plugin handled the error, check if it provides a response
           if (errorContext.handled) {
@@ -644,8 +620,8 @@ export class FluxStackFramework {
     return null
   }
 
-  private async handleViteProxy(errorContext: any): Promise<Response> {
-    const vitePort = this.context.config.client?.port || 5173
+  private async handleViteProxy(errorContext: { request: Request; method?: string; headers?: Record<string, string> }): Promise<Response> {
+    const vitePort = this.cfg.client?.port || 5173
     const url = this.parseRequestURL(errorContext.request)
 
     try {
@@ -677,29 +653,7 @@ export class FluxStackFramework {
 
   use(plugin: Plugin) {
     try {
-      // Use the registry's public register method, but don't await it since we need sync operation
-      if (this.pluginRegistry.has(plugin.name)) {
-        throw new Error(`Plugin '${plugin.name}' is already registered`)
-      }
-
-      // Store plugin without calling setup - setup will be called in start()
-      // We need to manually set the plugin since register() is async but we need sync
-      (this.pluginRegistry as any).plugins.set(plugin.name, plugin)
-
-      // Update dependencies tracking
-      if ((plugin as FluxStack.Plugin).dependencies) {
-        (this.pluginRegistry as any).dependencies.set(plugin.name, (plugin as FluxStack.Plugin).dependencies)
-      }
-
-      // Update load order by calling the private method
-      try {
-        (this.pluginRegistry as any).updateLoadOrder()
-      } catch (error) {
-        // Fallback: create basic load order
-        const plugins = (this.pluginRegistry as any).plugins as Map<string, Plugin>
-        const loadOrder = Array.from(plugins.keys())
-          ; (this.pluginRegistry as any).loadOrder = loadOrder
-      }
+      this.pluginRegistry.registerSync(plugin as FluxStack.Plugin)
 
       logger.debug(`Plugin '${plugin.name}' registered`, {
         version: (plugin as FluxStack.Plugin).version,
@@ -712,7 +666,7 @@ export class FluxStackFramework {
     }
   }
 
-  routes(routeModule: any) {
+  routes(routeModule: Elysia) {
     this.app.use(routeModule)
     return this
   }
@@ -724,8 +678,13 @@ export class FluxStackFramework {
     }
 
     try {
+      // Initialize automatic plugins before anything else
+      // This was previously fire-and-forget in the constructor, causing a race condition
+      // where listen() could be called before plugin discovery finished (issue #75)
+      await this.initializeAutomaticPlugins()
+
       // Validate plugin dependencies before starting
-      const plugins = (this.pluginRegistry as any).plugins as Map<string, FluxStack.Plugin>
+      const plugins = this.pluginRegistry.getPluginsMap()
       for (const [pluginName, plugin] of plugins) {
         if (plugin.dependencies) {
           for (const depName of plugin.dependencies) {
@@ -762,8 +721,9 @@ export class FluxStackFramework {
       for (const pluginName of loadOrder) {
         const plugin = this.pluginRegistry.get(pluginName)!
 
-        if ((plugin as any).plugin) {
-          this.app.use((plugin as any).plugin)
+        const pluginWithRoutes = plugin as FluxStack.Plugin & { plugin?: Elysia }
+        if (pluginWithRoutes.plugin) {
+          this.app.use(pluginWithRoutes.plugin)
           logger.debug(`Plugin '${pluginName}' routes mounted`)
         }
       }
@@ -849,21 +809,21 @@ export class FluxStackFramework {
     // Start the framework (load plugins)
     await this.start()
 
-    const port = this.context.config.server.port
-    const apiPrefix = this.context.config.server.apiPrefix
+    const port = this.cfg.server.port
+    const apiPrefix = this.cfg.server.apiPrefix
 
     this.app.listen(port, () => {
-      const showBanner = this.context.config.server.showBanner !== false // default: true
+      const showBanner = this.cfg.server.showBanner !== false // default: true
       const vitePluginActive = this.pluginRegistry.has('vite')
 
       // Prepare startup info for banner or callback
       const startupInfo: StartupInfo = {
         port,
-        host: this.context.config.server.host || 'localhost',
+        host: this.cfg.server.host || 'localhost',
         apiPrefix,
         environment: this.context.environment,
         pluginCount: this.pluginRegistry.getAll().length,
-        vitePort: this.context.config.client?.port,
+        vitePort: this.cfg.client?.port,
         viteEmbedded: vitePluginActive, // Vite is embedded when plugin is active
         swaggerPath: '/swagger', // TODO: Get from swagger plugin config
         liveComponents: componentRegistry.getRegisteredComponentNames()

package/core/framework/types.ts

@@ -42,7 +42,7 @@ export interface RouteDefinition {
   method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD'
   path: string
   handler: Function
-  schema?: any
+  schema?: unknown
   middleware?: Function[]
   description?: string
   tags?: string[]
@@ -57,7 +57,7 @@ export interface MiddlewareDefinition {
 
 export interface ServiceDefinition {
   name: string
-  instance: any
+  instance: unknown
   dependencies?: string[]
   singleton?: boolean
 }

package/core/plugins/built-in/live-components/commands/create-live-component.ts

@@ -218,7 +218,7 @@ export function ${name}Demo() {
         <input {...form.$field('email', { syncOn: 'change', debounce: 500 })} type="email" placeholder="Email" className="w-full px-3 py-2 border rounded-lg" />
         <textarea {...form.$field('message', { syncOn: 'blur' })} placeholder="Mensagem" rows={3} className="w-full px-3 py-2 border rounded-lg" />
         <div className="flex gap-2">
-          <button onClick={async () => { try { await form.$sync(); await form.submit() } catch (e: any) { alert(e.message) }}} className="flex-1 px-4 py-2 bg-blue-500 text-white rounded-lg">Enviar</button>
+          <button onClick={async () => { try { await form.$sync(); await form.submit() } catch (e) { alert((e as Error).message) }}} className="flex-1 px-4 py-2 bg-blue-500 text-white rounded-lg">Enviar</button>
           <button onClick={() => form.reset()} className="px-4 py-2 bg-gray-500 text-white rounded-lg">Limpar</button>
         </div>
       </div>
@@ -327,8 +327,11 @@ export const createLiveComponentCommand: CliCommand = {
     { name: "force", short: "f", description: "Overwrite", type: "boolean" }
   ],
   handler: async (args, options, context) => {
-    const [name] = args;
-    const { type = 'basic', 'no-client': noClient, room, force } = options;
+    const [rawName] = args;
+    const name = rawName as string;
+    const { type: rawType = 'basic', 'no-client': noClient, room: rawRoom, force } = options;
+    const type = rawType as string;
+    const room = rawRoom as string | undefined;
 
     if (!name || !/^[A-Z][a-zA-Z0-9]*$/.test(name)) {
       context.logger.error("❌ Nome inválido. Use PascalCase (ex: MeuComponente)");