create-fluxstack 1.15.0 → 1.17.0

package/core/server/plugins/database.ts

@@ -1,181 +1,182 @@
-import type { FluxStack, PluginContext, CliCommand, Plugin } from "../../plugins/types"
-
-// Database plugin with CLI commands
-export const databasePlugin: Plugin = {
-  name: "database",
-  description: "Database management plugin with CLI commands",
-  author: "FluxStack Team",
-  category: "data",
-
-  setup: (context: PluginContext) => {
-    context.logger.info("Database plugin initialized")
-  },
-
-  commands: [
-    {
-      name: "migrate",
-      description: "Run database migrations",
-      category: "Database",
-      usage: "flux database:migrate [options]",
-      examples: [
-        "flux database:migrate                # Run all pending migrations",
-        "flux database:migrate --rollback     # Rollback last migration",
-        "flux database:migrate --to 001       # Migrate to specific version"
-      ],
-      options: [
-        {
-          name: "rollback",
-          short: "r",
-          description: "Rollback the last migration",
-          type: "boolean"
-        },
-        {
-          name: "to",
-          description: "Migrate to specific version",
-          type: "string"
-        },
-        {
-          name: "dry-run",
-          description: "Show what would be migrated without executing",
-          type: "boolean"
-        }
-      ],
-      handler: async (args, options, context) => {
-        if (options["dry-run"]) {
-          console.log("🔍 Dry run mode - showing planned migrations:")
-        }
-
-        if (options.rollback) {
-          console.log("⬇️  Rolling back last migration...")
-          // Simulate rollback
-          await new Promise(resolve => setTimeout(resolve, 1000))
-          console.log("✅ Rollback completed")
-        } else if (options.to) {
-          console.log(`📈 Migrating to version: ${options.to}`)
-          // Simulate migration to version
-          await new Promise(resolve => setTimeout(resolve, 1500))
-          console.log(`✅ Migrated to version ${options.to}`)
-        } else {
-          console.log("📈 Running all pending migrations...")
-          // Simulate migration
-          await new Promise(resolve => setTimeout(resolve, 2000))
-          console.log("✅ All migrations completed")
-        }
-      }
-    },
-    {
-      name: "seed",
-      description: "Seed the database with initial data",
-      category: "Database", 
-      usage: "flux database:seed [seeder]",
-      examples: [
-        "flux database:seed                   # Run all seeders",
-        "flux database:seed users             # Run specific seeder"
-      ],
-      arguments: [
-        {
-          name: "seeder",
-          description: "Specific seeder to run",
-          required: false,
-          type: "string"
-        }
-      ],
-      options: [
-        {
-          name: "force",
-          short: "f",
-          description: "Force seeding even if data exists",
-          type: "boolean"
-        }
-      ],
-      handler: async (args, options, context) => {
-        const [seeder] = args
-        
-        if (seeder) {
-          console.log(`🌱 Running seeder: ${seeder}`)
-          console.log(`   Force mode: ${options.force ? 'ON' : 'OFF'}`)
-        } else {
-          console.log("🌱 Running all seeders...")
-        }
-        
-        // Simulate seeding
-        await new Promise(resolve => setTimeout(resolve, 1500))
-        console.log("✅ Database seeded successfully")
-      }
-    },
-    {
-      name: "reset",
-      description: "Reset the database (drop all tables and recreate)",
-      category: "Database",
-      usage: "flux database:reset [options]",
-      examples: [
-        "flux database:reset                  # Reset and migrate",
-        "flux database:reset --seed           # Reset, migrate and seed"
-      ],
-      options: [
-        {
-          name: "seed",
-          short: "s",
-          description: "Run seeders after reset",
-          type: "boolean"
-        },
-        {
-          name: "confirm",
-          description: "Skip confirmation prompt",
-          type: "boolean"
-        }
-      ],
-      handler: async (args, options, context) => {
-        if (!options.confirm) {
-          console.log("⚠️  WARNING: This will delete all data in the database!")
-          console.log("Use --confirm to skip this prompt.")
-          return
-        }
-
-        console.log("🗑️  Dropping all tables...")
-        await new Promise(resolve => setTimeout(resolve, 1000))
-        
-        console.log("📈 Running migrations...")
-        await new Promise(resolve => setTimeout(resolve, 1500))
-        
-        if (options.seed) {
-          console.log("🌱 Running seeders...")
-          await new Promise(resolve => setTimeout(resolve, 1000))
-        }
-        
-        console.log("✅ Database reset completed")
-      }
-    },
-    {
-      name: "status",
-      description: "Show database migration status",
-      category: "Database",
-      aliases: ["info"],
-      handler: async (args, options, context) => {
-        console.log("📊 Database Status:")
-        console.log("------------------")
-        console.log("Connected: ✅ Yes")
-        console.log("Tables: 15")
-        console.log("Last migration: 2024_01_15_create_users_table")
-        console.log("Pending migrations: 2")
-        console.log("Database size: 2.3 MB")
-      }
-    }
-  ]
-}
-
-// Utility functions that could be used by the plugin
-export async function runMigration(version?: string): Promise<void> {
-  // Actual migration logic would go here
-  console.log(`Running migration ${version || 'all'}`)
-}
-
-export async function rollbackMigration(): Promise<void> {
-  // Actual rollback logic would go here 
-  console.log("Rolling back migration")
-}
-
-export async function seedDatabase(seeder?: string): Promise<void> {
-  // Actual seeding logic would go here
-  console.log(`Seeding database ${seeder || 'all'}`)
+import type { FluxStack, PluginContext, CliCommand, Plugin } from "../../plugins/types"
+import { logger } from "@core/utils/logger"
+
+// Database plugin with CLI commands
+export const databasePlugin: Plugin = {
+  name: "database",
+  description: "Database management plugin with CLI commands",
+  author: "FluxStack Team",
+  category: "data",
+
+  setup: (context: PluginContext) => {
+    context.logger.info("Database plugin initialized")
+  },
+
+  commands: [
+    {
+      name: "migrate",
+      description: "Run database migrations",
+      category: "Database",
+      usage: "flux database:migrate [options]",
+      examples: [
+        "flux database:migrate                # Run all pending migrations",
+        "flux database:migrate --rollback     # Rollback last migration",
+        "flux database:migrate --to 001       # Migrate to specific version"
+      ],
+      options: [
+        {
+          name: "rollback",
+          short: "r",
+          description: "Rollback the last migration",
+          type: "boolean"
+        },
+        {
+          name: "to",
+          description: "Migrate to specific version",
+          type: "string"
+        },
+        {
+          name: "dry-run",
+          description: "Show what would be migrated without executing",
+          type: "boolean"
+        }
+      ],
+      handler: async (args, options, context) => {
+        if (options["dry-run"]) {
+          logger.info("Dry run mode - showing planned migrations:")
+        }
+
+        if (options.rollback) {
+          logger.info("Rolling back last migration...")
+          // Simulate rollback
+          await new Promise(resolve => setTimeout(resolve, 1000))
+          logger.info("Rollback completed")
+        } else if (options.to) {
+          logger.info(`Migrating to version: ${options.to}`)
+          // Simulate migration to version
+          await new Promise(resolve => setTimeout(resolve, 1500))
+          logger.info(`Migrated to version ${options.to}`)
+        } else {
+          logger.info("Running all pending migrations...")
+          // Simulate migration
+          await new Promise(resolve => setTimeout(resolve, 2000))
+          logger.info("All migrations completed")
+        }
+      }
+    },
+    {
+      name: "seed",
+      description: "Seed the database with initial data",
+      category: "Database", 
+      usage: "flux database:seed [seeder]",
+      examples: [
+        "flux database:seed                   # Run all seeders",
+        "flux database:seed users             # Run specific seeder"
+      ],
+      arguments: [
+        {
+          name: "seeder",
+          description: "Specific seeder to run",
+          required: false,
+          type: "string"
+        }
+      ],
+      options: [
+        {
+          name: "force",
+          short: "f",
+          description: "Force seeding even if data exists",
+          type: "boolean"
+        }
+      ],
+      handler: async (args, options, context) => {
+        const [seeder] = args
+
+        if (seeder) {
+          logger.info(`Running seeder: ${seeder}`)
+          logger.info(`   Force mode: ${options.force ? 'ON' : 'OFF'}`)
+        } else {
+          logger.info("Running all seeders...")
+        }
+
+        // Simulate seeding
+        await new Promise(resolve => setTimeout(resolve, 1500))
+        logger.info("Database seeded successfully")
+      }
+    },
+    {
+      name: "reset",
+      description: "Reset the database (drop all tables and recreate)",
+      category: "Database",
+      usage: "flux database:reset [options]",
+      examples: [
+        "flux database:reset                  # Reset and migrate",
+        "flux database:reset --seed           # Reset, migrate and seed"
+      ],
+      options: [
+        {
+          name: "seed",
+          short: "s",
+          description: "Run seeders after reset",
+          type: "boolean"
+        },
+        {
+          name: "confirm",
+          description: "Skip confirmation prompt",
+          type: "boolean"
+        }
+      ],
+      handler: async (args, options, context) => {
+        if (!options.confirm) {
+          logger.warn("WARNING: This will delete all data in the database!")
+          logger.info("Use --confirm to skip this prompt.")
+          return
+        }
+
+        logger.info("Dropping all tables...")
+        await new Promise(resolve => setTimeout(resolve, 1000))
+
+        logger.info("Running migrations...")
+        await new Promise(resolve => setTimeout(resolve, 1500))
+
+        if (options.seed) {
+          logger.info("Running seeders...")
+          await new Promise(resolve => setTimeout(resolve, 1000))
+        }
+
+        logger.info("Database reset completed")
+      }
+    },
+    {
+      name: "status",
+      description: "Show database migration status",
+      category: "Database",
+      aliases: ["info"],
+      handler: async (args, options, context) => {
+        logger.info("Database Status:")
+        logger.info("------------------")
+        logger.info("Connected: Yes")
+        logger.info("Tables: 15")
+        logger.info("Last migration: 2024_01_15_create_users_table")
+        logger.info("Pending migrations: 2")
+        logger.info("Database size: 2.3 MB")
+      }
+    }
+  ]
+}
+
+// Utility functions that could be used by the plugin
+export async function runMigration(version?: string): Promise<void> {
+  // Actual migration logic would go here
+  logger.info(`Running migration ${version || 'all'}`)
+}
+
+export async function rollbackMigration(): Promise<void> {
+  // Actual rollback logic would go here
+  logger.info("Rolling back migration")
+}
+
+export async function seedDatabase(seeder?: string): Promise<void> {
+  // Actual seeding logic would go here
+  logger.info(`Seeding database ${seeder || 'all'}`)
 }

package/core/server/plugins/static-files-plugin.ts

@@ -76,7 +76,7 @@ export const staticFilesPlugin: Plugin = {
     const enableUploads = pluginsConfig.staticEnableUploads
 
     // Async handler — uses Bun.file() APIs instead of Node fs
-    const serveFile = (baseDir: string, isUpload: boolean) => async ({ params, set, request }: any) => {
+    const serveFile = (baseDir: string, isUpload: boolean) => async ({ params, set, request }: { params: Record<string, string>; set: { status: number; headers: Record<string, string> }; request: Request }) => {
       const requestedPath: string = params['*'] || ''
 
       // Reject null bytes early — prevents filesystem confusion
@@ -155,15 +155,16 @@ export const staticFilesPlugin: Plugin = {
     }
 
     // Register routes based on config flags
+    const app = context.app as import('elysia').Elysia
     if (enablePublic) {
       await mkdir(publicDir, { recursive: true })
-      context.app.get('/api/static/*', serveFile(publicDir, false))
+      app.get('/api/static/*', serveFile(publicDir, false) as never)
       context.logger.debug('Static public files route registered: /api/static/*')
     }
 
     if (enableUploads) {
       await mkdir(uploadsDir, { recursive: true })
-      context.app.get('/api/uploads/*', serveFile(uploadsDir, true))
+      app.get('/api/uploads/*', serveFile(uploadsDir, true) as never)
       context.logger.debug('Static uploads route registered: /api/uploads/*')
     }
 

package/core/server/plugins/swagger.ts

@@ -4,7 +4,10 @@ import type { Plugin, PluginContext } from '@core/plugins/types'
 export const swaggerPlugin: Plugin = {
   name: 'swagger',
   setup(context: PluginContext) {
-    context.app.use(swagger({
+    const app = context.app as import('elysia').Elysia
+    const config = context.config as Record<string, unknown>
+    const server = config.server as Record<string, unknown> | undefined
+    app.use(swagger({
       path: '/swagger',
       documentation: {
         info: {
@@ -13,18 +16,18 @@ export const swaggerPlugin: Plugin = {
           description: 'Modern full-stack TypeScript framework with type-safe API endpoints'
         },
         tags: [
-          { 
-            name: 'Health', 
-            description: 'Health check endpoints' 
+          {
+            name: 'Health',
+            description: 'Health check endpoints'
           },
-          { 
-            name: 'Users', 
-            description: 'User management endpoints' 
+          {
+            name: 'Users',
+            description: 'User management endpoints'
           }
         ],
         servers: [
           {
-            url: `http://localhost:${context.config.server?.port || 3000}`,
+            url: `http://localhost:${server?.port || 3000}`,
             description: 'Development server'
           }
         ]

package/core/server/rooms/RoomBroadcaster.ts

@@ -2,6 +2,7 @@
 
 import type { ServerWebSocket } from 'bun'
 import type { Room, RoomSystem, SystemEvents } from './RoomSystem'
+import { logger } from "@core/utils/logger"
 
 type WebSocketLike = {
   send: (data: string) => void
@@ -19,12 +20,12 @@ interface BroadcastMessage {
   type: 'room:event' | 'room:state' | 'room:system'
   roomId: string
   event: string
-  data: any
+  data: unknown
   timestamp: number
   senderId?: string
 }
 
-export class RoomBroadcaster<TState, TEvents extends Record<string, any>> {
+export class RoomBroadcaster<TState, TEvents extends Record<string, unknown>> {
   private connections = new Map<string, RoomConnection>()
   private roomConnections = new Map<string, Set<string>>() // roomId -> connectionIds
   private roomSystem: RoomSystem<TState, TEvents>
@@ -156,7 +157,7 @@ export class RoomBroadcaster<TState, TEvents extends Record<string, any>> {
   broadcast(
     roomId: string,
     event: string,
-    data: any,
+    data: unknown,
     options?: { exclude?: string | string[] }
   ): number {
     const roomConns = this.roomConnections.get(roomId)
@@ -200,7 +201,7 @@ export class RoomBroadcaster<TState, TEvents extends Record<string, any>> {
   /**
    * Envia evento do sistema para todos na sala
    */
-  broadcastSystem(roomId: string, event: string, data: any): number {
+  broadcastSystem(roomId: string, event: string, data: unknown): number {
     const roomConns = this.roomConnections.get(roomId)
     if (!roomConns || roomConns.size === 0) return 0
 
@@ -238,7 +239,7 @@ export class RoomBroadcaster<TState, TEvents extends Record<string, any>> {
       connection.ws.send(JSON.stringify(message))
       return true
     } catch (error) {
-      console.error(`[RoomBroadcaster] Error sending to ${connectionId}:`, error)
+      logger.error(`[RoomBroadcaster] Error sending to ${connectionId}:`, error)
       return false
     }
   }
@@ -246,7 +247,7 @@ export class RoomBroadcaster<TState, TEvents extends Record<string, any>> {
   /**
    * Envia para um usuário específico (todas as conexões do usuário)
    */
-  sendToUser(userId: string, roomId: string, event: string, data: any): number {
+  sendToUser(userId: string, roomId: string, event: string, data: unknown): number {
     let sent = 0
 
     for (const [connId, conn] of this.connections) {
@@ -277,15 +278,15 @@ export class RoomBroadcaster<TState, TEvents extends Record<string, any>> {
     roomId: string,
     initialState: TState,
     connectionId?: string
-  ): Room<TState, TEvents> & { broadcastEmit: (event: keyof TEvents, data: any) => void } {
+  ): Room<TState, TEvents> & { broadcastEmit: <K extends keyof TEvents>(event: K, data: TEvents[K]) => void } {
     const room = this.roomSystem.getOrCreate(roomId, initialState)
 
     // Adicionar método de broadcast
     const enhanced = room as Room<TState, TEvents> & {
-      broadcastEmit: (event: keyof TEvents, data: any) => void
+      broadcastEmit: <K extends keyof TEvents>(event: K, data: TEvents[K]) => void
     }
 
-    enhanced.broadcastEmit = (event: keyof TEvents, data: any) => {
+    enhanced.broadcastEmit = <K extends keyof TEvents>(event: K, data: TEvents[K]) => {
       // Emitir localmente
       room.emit(event, data)
       // Broadcast via WebSocket
@@ -347,7 +348,7 @@ export class RoomBroadcaster<TState, TEvents extends Record<string, any>> {
 
 // Factory
 export function createRoomBroadcaster<
-  TDef extends { state: any; events: Record<string, any> }
+  TDef extends { state: unknown; events: Record<string, unknown> }
 >(
   roomSystem: RoomSystem<TDef['state'], TDef['events']>
 ): RoomBroadcaster<TDef['state'], TDef['events']> {

package/core/server/rooms/RoomSystem.ts

@@ -1,5 +1,8 @@
 // 🔥 FluxStack Room System - Pub/Sub tipado para comunicação entre componentes
 
+import { logger } from "@core/utils/logger"
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- default `any` needed for contravariant handler storage
 type EventHandler<T = any> = (data: T) => void
 type Unsubscribe = () => void
 
@@ -9,7 +12,7 @@ export type SystemEvents<TState> = {
   '$room:destroyed': { roomId: string; reason: 'manual' | 'empty' | 'ttl'; finalState: TState }
   '$sub:join': { subscriberId: string; event: string; count: number }
   '$sub:leave': { subscriberId: string; event: string; count: number }
-  '$state:change': { path?: string; oldValue: any; newValue: any }
+  '$state:change': { path?: string; oldValue: unknown; newValue: unknown }
   '$state:reset': { oldState: TState; newState: TState }
   '$error': { error: Error; context: string }
 }
@@ -25,7 +28,7 @@ interface Subscription {
 }
 
 // Room instance
-export class Room<TState, TEvents extends Record<string, any>> {
+export class Room<TState, TEvents extends Record<string, unknown>> {
   public readonly id: string
   public readonly createdAt: number
 
@@ -36,12 +39,12 @@ export class Room<TState, TEvents extends Record<string, any>> {
   private destroyed = false
 
   // Callback para notificar o sistema global
-  private onSystemEvent?: (event: string, data: any) => void
+  private onSystemEvent?: (event: string, data: unknown) => void
 
   constructor(
     id: string,
     initialState: TState,
-    onSystemEvent?: (event: string, data: any) => void
+    onSystemEvent?: (event: string, data: unknown) => void
   ) {
     this.id = id
     this.createdAt = Date.now()
@@ -167,7 +170,7 @@ export class Room<TState, TEvents extends Record<string, any>> {
     this.onSystemEvent?.(event as string, { roomId: this.id, ...data })
   }
 
-  private emitInternal(event: string, data: any): number {
+  private emitInternal(event: string, data: unknown): number {
     const subs = this.subscriptions.get(event)
     if (!subs || subs.size === 0) return 0
 
@@ -177,7 +180,7 @@ export class Room<TState, TEvents extends Record<string, any>> {
         sub.handler(data)
         notified++
       } catch (error) {
-        console.error(`[Room:${this.id}] Error in handler for '${event}':`, error)
+        logger.error(`[Room:${this.id}] Error in handler for '${event}':`, error)
         this.emitSystem('$error', {
           error: error as Error,
           context: `Handler for event '${event}'`
@@ -242,7 +245,7 @@ export interface RoomSystemOptions {
   defaultTTL?: number          // TTL padrão para salas
 }
 
-export class RoomSystem<TState, TEvents extends Record<string, any>> {
+export class RoomSystem<TState, TEvents extends Record<string, unknown>> {
   public readonly name: string
   private rooms = new Map<string, Room<TState, TEvents>>()
   private globalSubscriptions = new Map<string, Set<EventHandler>>()
@@ -383,11 +386,11 @@ export class RoomSystem<TState, TEvents extends Record<string, any>> {
     }
   }
 
-  private handleSystemEvent(event: string, data: any): void {
+  private handleSystemEvent(event: string, data: unknown): void {
     this.emitGlobal(event, data)
   }
 
-  private emitGlobal(event: string, data: any): void {
+  private emitGlobal(event: string, data: unknown): void {
     const handlers = this.globalSubscriptions.get(event)
     if (!handlers) return
 
@@ -395,7 +398,7 @@ export class RoomSystem<TState, TEvents extends Record<string, any>> {
       try {
         handler(data)
       } catch (error) {
-        console.error(`[RoomSystem:${this.name}] Error in global handler for '${event}':`, error)
+        logger.error(`[RoomSystem:${this.name}] Error in global handler for '${event}':`, error)
       }
     }
   }
@@ -448,7 +451,7 @@ export class RoomSystem<TState, TEvents extends Record<string, any>> {
 // ============================================
 
 export function createRoomSystem<
-  TDef extends { state: any; events: Record<string, any> }
+  TDef extends { state: unknown; events: Record<string, unknown> }
 >(
   name: string,
   options?: RoomSystemOptions