create-fluxstack 1.8.1 → 1.8.3

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

@@ -1,232 +1,260 @@
-// 🔥 FluxStack Static Files Plugin - Serve Public Files
-
-import { existsSync, statSync } from 'fs'
-import { join, extname, resolve } from 'path'
-import type { FluxStack, PluginContext } from '../plugins/types'
-
-export interface StaticFilesConfig {
-  publicDir?: string // Default: 'public'
-  uploadsDir?: string // Default: 'uploads'
-  cacheMaxAge?: number // Default: 1 year in seconds
-  enableUploads?: boolean // Default: true
-  enablePublic?: boolean // Default: true
-  publicRoute?: string // Default: '/public' (can be '/static' in dev)
-  uploadsRoute?: string // Default: '/uploads'
-}
-
-export const staticFilesPlugin: Plugin = {
-  name: 'static-files',
-  version: '1.0.0',
-  description: 'Serve static files and uploads with proper caching and security',
-  author: 'FluxStack Team',
-  priority: 'normal',
-  category: 'core',
-  tags: ['static', 'files', 'uploads', 'public'],
-  
-  setup: async (context: PluginContext) => {
-    context.logger.debug('📁 Setting up Static Files plugin...')
-    
-    const config: StaticFilesConfig = {
-      publicDir: 'public',
-      uploadsDir: 'uploads', 
-      cacheMaxAge: 31536000, // 1 year
-      enableUploads: true,
-      enablePublic: true,
-      publicRoute: '/api/static', // Use /api/static in dev to avoid Vite conflicts
-      uploadsRoute: '/api/uploads',
-      ...context.config.staticFiles
-    }
-    
-    const projectRoot = process.cwd()
-    const publicPath = resolve(projectRoot, config.publicDir!)
-    const uploadsPath = resolve(projectRoot, config.uploadsDir!)
-    
-    // MIME types mapping
-    const getMimeType = (extension: string): string => {
-      const mimeTypes: Record<string, string> = {
-        // Images
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg', 
-        '.png': 'image/png',
-        '.gif': 'image/gif',
-        '.webp': 'image/webp',
-        '.svg': 'image/svg+xml',
-        '.ico': 'image/x-icon',
-        
-        // Documents
-        '.pdf': 'application/pdf',
-        '.txt': 'text/plain',
-        '.json': 'application/json',
-        '.xml': 'application/xml',
-        
-        // Web assets
-        '.css': 'text/css',
-        '.js': 'application/javascript',
-        '.html': 'text/html',
-        '.htm': 'text/html',
-        
-        // Fonts
-        '.woff': 'font/woff',
-        '.woff2': 'font/woff2',
-        '.ttf': 'font/ttf',
-        '.otf': 'font/otf',
-        
-        // Audio/Video
-        '.mp3': 'audio/mpeg',
-        '.mp4': 'video/mp4',
-        '.webm': 'video/webm',
-        '.ogg': 'audio/ogg'
-      }
-      
-      return mimeTypes[extension.toLowerCase()] || 'application/octet-stream'
-    }
-    
-    // Security check for path traversal
-    const isPathSafe = (filePath: string, basePath: string): boolean => {
-      const resolvedPath = resolve(basePath, filePath)
-      return resolvedPath.startsWith(basePath)
-    }
-    
-    // Generic file serving function
-    const serveFile = async (filePath: string, set: any) => {
-      try {
-        if (!existsSync(filePath)) {
-          set.status = 404
-          return { 
-            error: 'File not found',
-            path: filePath.replace(projectRoot, ''),
-            timestamp: new Date().toISOString()
-          }
-        }
-        
-        const stats = statSync(filePath)
-        if (!stats.isFile()) {
-          set.status = 404
-          return { error: 'Not a file' }
-        }
-        
-        // Set appropriate headers
-        const extension = extname(filePath).toLowerCase()
-        const mimeType = getMimeType(extension)
-        
-        set.headers['content-type'] = mimeType
-        set.headers['content-length'] = stats.size.toString()
-        set.headers['last-modified'] = stats.mtime.toUTCString()
-        set.headers['cache-control'] = `public, max-age=${config.cacheMaxAge}`
-        set.headers['etag'] = `"${stats.mtime.getTime()}-${stats.size}"`
-        
-        // Security headers for images
-        if (mimeType.startsWith('image/')) {
-          set.headers['x-content-type-options'] = 'nosniff'
-        }
-        
-        context.logger.debug(`📁 Serving file: ${filePath.replace(projectRoot, '')}`, {
-          size: stats.size,
-          mimeType,
-          lastModified: stats.mtime
-        })
-        
-        return Bun.file(filePath)
-        
-      } catch (error: any) {
-        context.logger.error('❌ File serving error:', error.message)
-        set.status = 500
-        return { error: 'Failed to serve file' }
-      }
-    }
-    
-    // Add static file routes
-    if (config.enablePublic) {
-      const publicRoutePattern = `${config.publicRoute}/*`
-      context.app.get(publicRoutePattern, ({ params, set }) => {
-        const filePath = params['*'] || ''
-        
-        if (!isPathSafe(filePath, publicPath)) {
-          set.status = 400
-          return { error: 'Invalid file path' }
-        }
-        
-        const fullPath = join(publicPath, filePath)
-        return serveFile(fullPath, set)
-      })
-      
-      context.logger.debug(`📁 Public files route enabled: ${publicRoutePattern} → ${config.publicDir}`)
-    }
-    
-    if (config.enableUploads) {
-      const uploadsRoutePattern = `${config.uploadsRoute}/*`
-      context.app.get(uploadsRoutePattern, ({ params, set }) => {
-        const filePath = params['*'] || ''
-        
-        if (!isPathSafe(filePath, uploadsPath)) {
-          set.status = 400
-          return { error: 'Invalid file path' }
-        }
-        
-        const fullPath = join(uploadsPath, filePath)
-        return serveFile(fullPath, set)
-      })
-      
-      context.logger.debug(`📁 Uploads route enabled: ${uploadsRoutePattern} → ${config.uploadsDir}`)
-    }
-    
-    // Static files info endpoint
-    context.app.get('/api/static/info', () => {
-      return {
-        success: true,
-        config: {
-          publicDir: config.publicDir,
-          uploadsDir: config.uploadsDir,
-          enablePublic: config.enablePublic,
-          enableUploads: config.enableUploads,
-          cacheMaxAge: config.cacheMaxAge
-        },
-        paths: {
-          publicPath,
-          uploadsPath,
-          publicUrl: config.publicRoute,
-          uploadsUrl: config.uploadsRoute
-        },
-        timestamp: new Date().toISOString()
-      }
-    })
-    
-    // Create directories if they don't exist
-    const { mkdir } = await import('fs/promises')
-    
-    if (config.enablePublic && !existsSync(publicPath)) {
-      await mkdir(publicPath, { recursive: true })
-      context.logger.debug(`📁 Created public directory: ${publicPath}`)
-    }
-    
-    if (config.enableUploads && !existsSync(uploadsPath)) {
-      await mkdir(uploadsPath, { recursive: true })
-      await mkdir(join(uploadsPath, 'avatars'), { recursive: true })
-      context.logger.debug(`📁 Created uploads directory: ${uploadsPath}`)
-    }
-    
-    context.logger.debug('📁 Static Files plugin setup complete', {
-      publicEnabled: config.enablePublic,
-      uploadsEnabled: config.enableUploads,
-      publicPath: config.enablePublic ? publicPath : 'disabled',
-      uploadsPath: config.enableUploads ? uploadsPath : 'disabled'
-    })
-  },
-
-  onServerStart: async (context: PluginContext) => {
-    const config = {
-      enablePublic: true,
-      enableUploads: true,
-      publicRoute: '/api/static',
-      uploadsRoute: '/api/uploads',
-      ...context.config.staticFiles
-    }
-    context.logger.debug('📁 Static Files plugin ready', {
-      routes: [
-        config.enablePublic ? `${config.publicRoute}/*` : null,
-        config.enableUploads ? `${config.uploadsRoute}/*` : null,
-        '/api/static/info'
-      ].filter(Boolean)
-    })
-  }
+// 🔥 FluxStack Static Files Plugin - Serve Public Files
+
+import { existsSync, statSync } from 'fs'
+import { join, extname, resolve } from 'path'
+import type { FluxStack, PluginContext, Plugin } from '../../plugins/types'
+import { t } from 'elysia'
+
+// Response schema for static files info endpoint
+const StaticFilesInfoSchema = t.Object({
+  success: t.Boolean(),
+  config: t.Object({
+    publicDir: t.String(),
+    uploadsDir: t.String(),
+    enablePublic: t.Boolean(),
+    enableUploads: t.Boolean(),
+    cacheMaxAge: t.Number()
+  }),
+  paths: t.Object({
+    publicPath: t.String(),
+    uploadsPath: t.String(),
+    publicUrl: t.String(),
+    uploadsUrl: t.String()
+  }),
+  timestamp: t.String()
+}, {
+  description: 'Static files configuration and paths information'
+})
+
+export interface StaticFilesConfig {
+  publicDir?: string // Default: 'public'
+  uploadsDir?: string // Default: 'uploads'
+  cacheMaxAge?: number // Default: 1 year in seconds
+  enableUploads?: boolean // Default: true
+  enablePublic?: boolean // Default: true
+  publicRoute?: string // Default: '/public' (can be '/static' in dev)
+  uploadsRoute?: string // Default: '/uploads'
+}
+
+export const staticFilesPlugin: Plugin = {
+  name: 'static-files',
+  description: 'Serve static files and uploads with proper caching and security',
+  author: 'FluxStack Team',
+  priority: 'normal',
+  category: 'core',
+  tags: ['static', 'files', 'uploads', 'public'],
+  
+  setup: async (context: PluginContext) => {
+    context.logger.debug('📁 Setting up Static Files plugin...')
+    
+    const config: StaticFilesConfig = {
+      publicDir: 'public',
+      uploadsDir: 'uploads', 
+      cacheMaxAge: 31536000, // 1 year
+      enableUploads: true,
+      enablePublic: true,
+      publicRoute: '/api/static', // Use /api/static in dev to avoid Vite conflicts
+      uploadsRoute: '/api/uploads',
+      ...context.config.staticFiles
+    }
+    
+    const projectRoot = process.cwd()
+    const publicPath = resolve(projectRoot, config.publicDir!)
+    const uploadsPath = resolve(projectRoot, config.uploadsDir!)
+    
+    // MIME types mapping
+    const getMimeType = (extension: string): string => {
+      const mimeTypes: Record<string, string> = {
+        // Images
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg', 
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        
+        // Documents
+        '.pdf': 'application/pdf',
+        '.txt': 'text/plain',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        
+        // Web assets
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        
+        // Fonts
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.otf': 'font/otf',
+        
+        // Audio/Video
+        '.mp3': 'audio/mpeg',
+        '.mp4': 'video/mp4',
+        '.webm': 'video/webm',
+        '.ogg': 'audio/ogg'
+      }
+      
+      return mimeTypes[extension.toLowerCase()] || 'application/octet-stream'
+    }
+    
+    // Security check for path traversal
+    const isPathSafe = (filePath: string, basePath: string): boolean => {
+      const resolvedPath = resolve(basePath, filePath)
+      return resolvedPath.startsWith(basePath)
+    }
+    
+    // Generic file serving function
+    const serveFile = async (filePath: string, set: any) => {
+      try {
+        if (!existsSync(filePath)) {
+          set.status = 404
+          return { 
+            error: 'File not found',
+            path: filePath.replace(projectRoot, ''),
+            timestamp: new Date().toISOString()
+          }
+        }
+        
+        const stats = statSync(filePath)
+        if (!stats.isFile()) {
+          set.status = 404
+          return { error: 'Not a file' }
+        }
+        
+        // Set appropriate headers
+        const extension = extname(filePath).toLowerCase()
+        const mimeType = getMimeType(extension)
+        
+        set.headers['content-type'] = mimeType
+        set.headers['content-length'] = stats.size.toString()
+        set.headers['last-modified'] = stats.mtime.toUTCString()
+        set.headers['cache-control'] = `public, max-age=${config.cacheMaxAge}`
+        set.headers['etag'] = `"${stats.mtime.getTime()}-${stats.size}"`
+        
+        // Security headers for images
+        if (mimeType.startsWith('image/')) {
+          set.headers['x-content-type-options'] = 'nosniff'
+        }
+        
+        context.logger.debug(`📁 Serving file: ${filePath.replace(projectRoot, '')}`, {
+          size: stats.size,
+          mimeType,
+          lastModified: stats.mtime
+        })
+        
+        return Bun.file(filePath)
+        
+      } catch (error: any) {
+        context.logger.error('❌ File serving error:', error.message)
+        set.status = 500
+        return { error: 'Failed to serve file' }
+      }
+    }
+    
+    // Add static file routes
+    if (config.enablePublic) {
+      const publicRoutePattern = `${config.publicRoute}/*`
+      context.app.get(publicRoutePattern, ({ params, set }) => {
+        const filePath = params['*'] || ''
+        
+        if (!isPathSafe(filePath, publicPath)) {
+          set.status = 400
+          return { error: 'Invalid file path' }
+        }
+        
+        const fullPath = join(publicPath, filePath)
+        return serveFile(fullPath, set)
+      })
+      
+      context.logger.debug(`📁 Public files route enabled: ${publicRoutePattern} → ${config.publicDir}`)
+    }
+    
+    if (config.enableUploads) {
+      const uploadsRoutePattern = `${config.uploadsRoute}/*`
+      context.app.get(uploadsRoutePattern, ({ params, set }) => {
+        const filePath = params['*'] || ''
+        
+        if (!isPathSafe(filePath, uploadsPath)) {
+          set.status = 400
+          return { error: 'Invalid file path' }
+        }
+        
+        const fullPath = join(uploadsPath, filePath)
+        return serveFile(fullPath, set)
+      })
+      
+      context.logger.debug(`📁 Uploads route enabled: ${uploadsRoutePattern} → ${config.uploadsDir}`)
+    }
+    
+    // Static files info endpoint
+    context.app.get('/api/static/info', () => {
+      return {
+        success: true,
+        config: {
+          publicDir: config.publicDir,
+          uploadsDir: config.uploadsDir,
+          enablePublic: config.enablePublic,
+          enableUploads: config.enableUploads,
+          cacheMaxAge: config.cacheMaxAge
+        },
+        paths: {
+          publicPath,
+          uploadsPath,
+          publicUrl: config.publicRoute,
+          uploadsUrl: config.uploadsRoute
+        },
+        timestamp: new Date().toISOString()
+      }
+    }, {
+      detail: {
+        summary: 'Static Files Configuration',
+        description: 'Returns configuration and paths for static files and uploads serving',
+        tags: ['Static Files', 'Configuration']
+      },
+      response: StaticFilesInfoSchema
+    })
+    
+    // Create directories if they don't exist
+    const { mkdir } = await import('fs/promises')
+    
+    if (config.enablePublic && !existsSync(publicPath)) {
+      await mkdir(publicPath, { recursive: true })
+      context.logger.debug(`📁 Created public directory: ${publicPath}`)
+    }
+    
+    if (config.enableUploads && !existsSync(uploadsPath)) {
+      await mkdir(uploadsPath, { recursive: true })
+      await mkdir(join(uploadsPath, 'avatars'), { recursive: true })
+      context.logger.debug(`📁 Created uploads directory: ${uploadsPath}`)
+    }
+    
+    context.logger.debug('📁 Static Files plugin setup complete', {
+      publicEnabled: config.enablePublic,
+      uploadsEnabled: config.enableUploads,
+      publicPath: config.enablePublic ? publicPath : 'disabled',
+      uploadsPath: config.enableUploads ? uploadsPath : 'disabled'
+    })
+  },
+
+  onServerStart: async (context: PluginContext) => {
+    const config = {
+      enablePublic: true,
+      enableUploads: true,
+      publicRoute: '/api/static',
+      uploadsRoute: '/api/uploads',
+      ...context.config.staticFiles
+    }
+    context.logger.debug('📁 Static Files plugin ready', {
+      routes: [
+        config.enablePublic ? `${config.publicRoute}/*` : null,
+        config.enableUploads ? `${config.uploadsRoute}/*` : null,
+        '/api/static/info'
+      ].filter(Boolean)
+    })
+  }
 }

package/core/server/plugins/swagger.ts

@@ -1,5 +1,5 @@
 import { swagger } from '@elysiajs/swagger'
-import type { Plugin, PluginContext } from '../../types'
+import type { Plugin, PluginContext } from '@/core/plugins/types'
 
 export const swaggerPlugin: Plugin = {
   name: 'swagger',

package/core/server/services/BaseService.ts

@@ -8,7 +8,7 @@
  * - Service container integration
  */
 
-import type { Logger } from '../../utils/logger/index.js'
+import type { Logger } from '@/core/utils/logger/index'
 
 export interface ServiceContext {
   config: any

package/core/server/services/ServiceContainer.ts

@@ -5,7 +5,7 @@
  * Provides service registration, resolution, and lifecycle management
  */
 
-import type { Logger } from '../../utils/logger/index.js'
+import type { Logger } from '@/core/utils/logger/index'
 
 export interface ServiceDefinition {
   factory: (container: ServiceContainer) => any

package/core/server/services/index.ts

@@ -3,7 +3,7 @@
  * FluxStack service infrastructure exports
  */
 
-export { BaseService } from './BaseService.js'
-export { ServiceContainer } from './ServiceContainer.js'
-export type { ServiceContext, ServiceContainer as IServiceContainer } from './BaseService.js'
-export type { ServiceDefinition } from './ServiceContainer.js'
+export { BaseService } from './BaseService'
+export { ServiceContainer } from './ServiceContainer'
+export type { ServiceContext, ServiceContainer as IServiceContainer } from './BaseService'
+export type { ServiceDefinition } from './ServiceContainer'

package/core/server/standalone.ts

@@ -2,6 +2,21 @@
 import { FluxStackFramework } from "./index"
 import type { Plugin, PluginContext } from "../types"
 
+/**
+ * Helper to safely parse request.url which might be relative or absolute
+ */
+function parseRequestURL(request: Request): URL {
+  try {
+    // Try parsing as absolute URL first
+    return new URL(request.url)
+  } catch {
+    // If relative, use host from headers or default to localhost
+    const host = request.headers.get('host') || 'localhost'
+    const protocol = request.headers.get('x-forwarded-proto') || 'http'
+    return new URL(request.url, `${protocol}://${host}`)
+  }
+}
+
 export const createStandaloneServer = (userConfig: any = {}) => {
   const app = new FluxStackFramework({
     server: {
@@ -29,7 +44,7 @@ export const createStandaloneServer = (userConfig: any = {}) => {
       context.app.onRequest(({ request }: { request: Request }) => {
         // Log mais limpo para backend standalone
         const timestamp = new Date().toLocaleTimeString()
-        const path = new URL(request.url).pathname
+        const path = parseRequestURL(request).pathname
         console.log(`[${timestamp}] ${request.method} ${path}`)
       })
     }

package/core/testing/index.ts

@@ -7,4 +7,4 @@ export {
   setupFluxStackTests, 
   createMockLogger, 
   createMockServiceContext 
-} from './setup.js'
+} from './setup'

package/core/testing/setup.ts

@@ -10,7 +10,7 @@ import { beforeEach, vi } from 'vitest'
  */
 export function setupFluxStackTests() {
   // Mock fetch globally
-  global.fetch = vi.fn()
+  global.fetch = vi.fn() as any
 
   // Mock localStorage
   const localStorageMock = {

package/core/utils/logger/startup-banner.ts

@@ -33,43 +33,17 @@ export function displayStartupBanner(info: StartupInfo): void {
     pluginCount = 0,
     vitePort,
     viteEmbedded = false,
-    swaggerPath
   } = info
 
-  console.log('\n' + chalk.cyan.bold('⚡ FluxStack') + chalk.gray(` v${FLUXSTACK_VERSION}\n`))
-
-  // Server info
-  console.log(chalk.bold('🚀 Server'))
-  console.log(`   ${chalk.gray('→')} http://localhost:${port}`)
-  console.log(`   ${chalk.gray('→')} API: http://localhost:${port}${apiPrefix}`)
-  console.log(`   ${chalk.gray('→')} Health: http://localhost:${port}${apiPrefix}/health`)
-
-  // Frontend info (only if Vite is running standalone, NOT embedded)
-  if (vitePort && !viteEmbedded) {
-    console.log('')
-    console.log(chalk.bold('⚛️  Frontend'))
-    console.log(`   ${chalk.gray('→')} http://localhost:${vitePort}`)
-  }
-
-  // Swagger docs (if enabled)
-  if (swaggerPath) {
-    console.log('')
-    console.log(chalk.bold('📋 Documentation'))
-    console.log(`   ${chalk.gray('→')} Swagger: http://localhost:${port}${swaggerPath}`)
-  }
-
-  // Environment and plugins
-  console.log('')
-  console.log(chalk.bold('ℹ️  Info'))
-  console.log(`   ${chalk.gray('→')} Environment: ${chalk.green(environment)}`)
-  console.log(`   ${chalk.gray('→')} Plugins: ${chalk.yellow(pluginCount)}`)
-
-  // Show Vite embedded status when applicable
-  if (viteEmbedded && vitePort) {
-    console.log(`   ${chalk.gray('→')} Vite: ${chalk.magenta('embedded')} ${chalk.gray(`(port ${vitePort})`)}`)
+  // Display plugins in compact format
+  const plugins = (global as any).__fluxstackPlugins || []
+  if (plugins.length > 0) {
+    const pluginList = plugins.map((p: any) => `${p.name} (${p.details})`).join(', ')
+    console.log(`Plugins (${plugins.length}): ${pluginList}\n`)
   }
 
-  console.log('\n' + chalk.green('✨ Ready!') + chalk.gray(' Press Ctrl+C to stop\n'))
+  // Simple ready message
+  console.log(chalk.green('Server ready!') + chalk.gray(` Environment: ${environment}${viteEmbedded ? ' | Vite: embedded' : ''}\n`))
 }
 
 /**