create-fluxstack 1.16.0 → 1.17.0

package/core/server/middleware/elysia-helpers.ts

@@ -8,7 +8,7 @@ import { Elysia } from 'elysia'
 /**
  * Options for creating middleware
  */
-export interface MiddlewareOptions<TContext = any> {
+export interface MiddlewareOptions<TContext = unknown> {
   /** Unique name for the middleware (required for Elysia) */
   name: string
 
@@ -16,7 +16,7 @@ export interface MiddlewareOptions<TContext = any> {
    * Handler function that runs before the route handler.
    * Return undefined to continue, or return a response to block execution.
    */
-  handler: (context: TContext) => void | Promise<void> | any | Promise<any>
+  handler: (context: TContext) => void | Promise<void> | unknown | Promise<unknown>
 
   /**
    * If true, uses derive() instead of onBeforeHandle().
@@ -44,17 +44,18 @@ export interface MiddlewareOptions<TContext = any> {
  * app.use(myAuth)
  * ```
  */
-export function createMiddleware<TContext = any>(
+export function createMiddleware<TContext = unknown>(
   options: MiddlewareOptions<TContext>
 ) {
   const { name, handler, nonBlocking = false } = options
 
+  // Elysia's derive/onBeforeHandle have complex overloaded type signatures
+  // that cannot be satisfied by a generic TContext handler. We cast through
+  // 'never' to bridge the generic handler with Elysia's strict internal types.
   if (nonBlocking) {
-    // Non-blocking: use derive() - adds to context without stopping execution
-    return new Elysia({ name }).derive(handler as any)
+    return new Elysia({ name }).derive(handler as never)
   } else {
-    // Blocking: use onBeforeHandle() - can stop execution by returning a response
-    return new Elysia({ name }).onBeforeHandle(handler as any)
+    return new Elysia({ name }).onBeforeHandle(handler as never)
   }
 }
 
@@ -71,9 +72,9 @@ export function createMiddleware<TContext = any>(
  * app.use(addTimestamp).get('/', ({ timestamp }) => ({ timestamp }))
  * ```
  */
-export function createDerive<TDerived extends Record<string, any>>(options: {
+export function createDerive<TDerived extends Record<string, unknown>>(options: {
   name: string
-  derive: (context: any) => TDerived | Promise<TDerived>
+  derive: (context: unknown) => TDerived | Promise<TDerived>
 }) {
   return new Elysia({ name: options.name }).derive(options.derive)
 }
@@ -97,16 +98,16 @@ export function createDerive<TDerived extends Record<string, any>>(options: {
  * app.use(requireAdmin).get('/admin', () => 'Admin panel')
  * ```
  */
-export function createGuard<TContext = any>(options: {
+export function createGuard<TContext = unknown>(options: {
   name: string
   check: (context: TContext) => boolean | Promise<boolean>
-  onFail: (set: any, context: TContext) => any
+  onFail: (set: unknown, context: TContext) => unknown
 }) {
   return new Elysia({ name: options.name })
     .onBeforeHandle(async (ctx) => {
       const passed = await options.check(ctx as TContext)
       if (!passed) {
-        return options.onFail((ctx as any).set, ctx as TContext)
+        return options.onFail((ctx as unknown as TContext & { set: unknown }).set, ctx as unknown as TContext)
       }
     })
 }
@@ -128,14 +129,14 @@ export function createRateLimit(options: {
   name: string
   maxRequests: number
   windowMs: number
-  keyGenerator?: (context: any) => string
+  keyGenerator?: (context: unknown) => string
   message?: string
 }) {
   const {
     name,
     maxRequests,
     windowMs,
-    keyGenerator = ({ request }: any) =>
+    keyGenerator = ({ request }: { request: Request }) =>
       request.headers.get('x-forwarded-for') ||
       request.headers.get('x-real-ip') ||
       'unknown',
@@ -171,7 +172,7 @@ export function createRateLimit(options: {
           requests.set(key, { count: 1, resetTime: now + windowMs })
         } else if (entry.count >= maxRequests) {
           // Rate limit exceeded
-          ;(ctx as any).set.status = 429
+          ;(ctx as { set: { status: number } }).set.status = 429
           return {
             success: false,
             error: 'RATE_LIMIT_EXCEEDED',

package/core/server/middleware/errorHandling.ts

@@ -8,17 +8,17 @@ export interface Request {
   url: string
   method: string
   ip?: string
-  [key: string]: any
+  [key: string]: unknown
 }
 
 export interface Response {
   status: (code: number) => Response
-  json: (data: any) => Response
-  [key: string]: any
+  json: (data: unknown) => Response
+  [key: string]: unknown
 }
 
 export interface NextFunction {
-  (error?: any): void
+  (error?: unknown): void
 }
 import type { Logger } from '@core/utils/logger/index'
 
@@ -31,7 +31,7 @@ export interface ErrorHandlingOptions {
 export interface FluxStackError extends Error {
   statusCode?: number
   code?: string
-  details?: any
+  details?: unknown
 }
 
 /**
@@ -66,24 +66,24 @@ export function errorHandlingMiddleware(options: ErrorHandlingOptions = {}) {
 
     // Default error response
     const statusCode = error.statusCode || 500
-    const response: any = {
-      error: {
-        message: error.message || 'Internal Server Error',
-        code: error.code || 'INTERNAL_ERROR',
-        statusCode
-      }
+    const errorBody: Record<string, unknown> = {
+      message: error.message || 'Internal Server Error',
+      code: error.code || 'INTERNAL_ERROR',
+      statusCode
     }
 
     // Include stack trace in development
     if (includeStack && error.stack) {
-      response.error.stack = error.stack
+      errorBody.stack = error.stack
     }
 
     // Include additional details if available
     if (error.details) {
-      response.error.details = error.details
+      errorBody.details = error.details
     }
 
+    const response = { error: errorBody }
+
     res.status(statusCode).json(response)
   }
 }
@@ -122,7 +122,7 @@ export function createError(
   message: string, 
   statusCode: number = 500, 
   code?: string, 
-  details?: any
+  details?: unknown
 ): FluxStackError {
   const error = new Error(message) as FluxStackError
   error.statusCode = statusCode

package/core/server/middleware/index.ts

@@ -1,32 +1,32 @@
-/**
- * Core Server Middleware
- * FluxStack middleware infrastructure exports
- */
-
-export {
-  errorHandlingMiddleware,
-  notFoundMiddleware,
-  createError,
-  asyncHandler
-} from './errorHandling'
-
-export type {
-  ErrorHandlingOptions,
-  FluxStackError
-} from './errorHandling'
-
-// Elysia Middleware Helpers
-export {
-  createMiddleware,
-  createDerive,
-  createGuard,
-  createRateLimit,
-  composeMiddleware,
-  isDevelopment,
-  isProduction,
-  isTest
-} from './elysia-helpers'
-
-export type {
-  MiddlewareOptions
+/**
+ * Core Server Middleware
+ * FluxStack middleware infrastructure exports
+ */
+
+export {
+  errorHandlingMiddleware,
+  notFoundMiddleware,
+  createError,
+  asyncHandler
+} from './errorHandling'
+
+export type {
+  ErrorHandlingOptions,
+  FluxStackError
+} from './errorHandling'
+
+// Elysia Middleware Helpers
+export {
+  createMiddleware,
+  createDerive,
+  createGuard,
+  createRateLimit,
+  composeMiddleware,
+  isDevelopment,
+  isProduction,
+  isTest
+} from './elysia-helpers'
+
+export type {
+  MiddlewareOptions
 } from './elysia-helpers'

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/*')
     }