create-fluxstack 1.8.3 → 1.10.1

package/core/server/live/FileUploadManager.ts

@@ -12,9 +12,9 @@ import type {
 
 export class FileUploadManager {
   private activeUploads = new Map<string, ActiveUpload>()
-  private readonly maxUploadSize = 50 * 1024 * 1024 // 50MB max
+  private readonly maxUploadSize = 500 * 1024 * 1024 // 500MB max (aceita qualquer arquivo)
   private readonly chunkTimeout = 30000 // 30 seconds timeout per chunk
-  private readonly allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp', 'image/gif']
+  private readonly allowedTypes: string[] = [] // Array vazio = aceita todos os tipos de arquivo
 
   constructor() {
     // Cleanup stale uploads every 5 minutes
@@ -25,12 +25,7 @@ export class FileUploadManager {
     try {
       const { uploadId, componentId, filename, fileType, fileSize, chunkSize = 64 * 1024 } = message
 
-      // Validate file type
-      if (!this.allowedTypes.includes(fileType)) {
-        throw new Error(`Invalid file type: ${fileType}. Allowed: ${this.allowedTypes.join(', ')}`)
-      }
-
-      // Validate file size
+      // Validate file size (sem restrição de tipo)
       if (fileSize > this.maxUploadSize) {
         throw new Error(`File too large: ${fileSize} bytes. Max: ${this.maxUploadSize} bytes`)
       }
@@ -52,6 +47,7 @@ export class FileUploadManager {
         fileSize,
         totalChunks,
         receivedChunks: new Map(),
+        bytesReceived: 0, // Track actual bytes for adaptive chunking
         startTime: Date.now(),
         lastChunkTime: Date.now()
       }
@@ -97,16 +93,20 @@ export class FileUploadManager {
         upload.receivedChunks.set(chunkIndex, data)
         upload.lastChunkTime = Date.now()
 
-        console.log(`📦 Received chunk ${chunkIndex + 1}/${totalChunks} for upload ${uploadId}`)
+        // Track actual bytes received (decode base64 to get real size)
+        const chunkBytes = Buffer.from(data, 'base64').length
+        upload.bytesReceived += chunkBytes
+
+        console.log(`📦 Received chunk ${chunkIndex + 1}/${totalChunks} for upload ${uploadId} (${chunkBytes} bytes, total: ${upload.bytesReceived}/${upload.fileSize})`)
       }
 
-      // Calculate progress
-      const progress = (upload.receivedChunks.size / totalChunks) * 100
-      const bytesUploaded = upload.receivedChunks.size * (upload.fileSize / totalChunks)
+      // Calculate progress based on actual bytes received (supports adaptive chunking)
+      const progress = (upload.bytesReceived / upload.fileSize) * 100
+      const bytesUploaded = upload.bytesReceived
 
-      // Check if upload is complete
-      if (upload.receivedChunks.size === totalChunks) {
-        await this.finalizeUpload(upload)
+      // Log completion status (but don't finalize until COMPLETE message)
+      if (upload.bytesReceived >= upload.fileSize) {
+        console.log(`✅ All bytes received for upload ${uploadId} (${upload.bytesReceived}/${upload.fileSize}), waiting for COMPLETE message`)
       }
 
       return {
@@ -152,19 +152,16 @@ export class FileUploadManager {
         throw new Error(`Upload ${uploadId} not found`)
       }
 
-      console.log(`✅ Upload completed: ${uploadId}`)
+      console.log(`✅ Upload completion requested: ${uploadId}`)
 
-      // Check for missing chunks
-      const missingChunks: number[] = []
-      for (let i = 0; i < upload.totalChunks; i++) {
-        if (!upload.receivedChunks.has(i)) {
-          missingChunks.push(i)
-        }
+      // Validate bytes received (supports adaptive chunking)
+      if (upload.bytesReceived !== upload.fileSize) {
+        const bytesShort = upload.fileSize - upload.bytesReceived
+        throw new Error(`Incomplete upload: received ${upload.bytesReceived}/${upload.fileSize} bytes (${bytesShort} bytes short)`)
       }
 
-      if (missingChunks.length > 0) {
-        throw new Error(`Missing chunks: ${missingChunks.join(', ')}`)
-      }
+      console.log(`✅ Upload validation passed: ${uploadId} (${upload.bytesReceived} bytes)`)
+
 
       // Assemble file from chunks
       const fileUrl = await this.assembleFile(upload)

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

@@ -1,26 +1,29 @@
-// 🔥 Auto-generated Live Components Registration
-// This file is automatically generated during build time - DO NOT EDIT MANUALLY
-// Generated at: 2025-11-12T22:57:08.521Z
-
-import { LiveClockComponent } from "@/app/server/live/LiveClockComponent"
-import { componentRegistry } from "@/core/server/live/ComponentRegistry"
-
-// Register all components statically for production bundle
-function registerAllComponents() {
-  try {
-    // Auto-generated component registrations
-    componentRegistry.registerComponentClass('LiveClock', LiveClockComponent)
-    
-    console.log('📝 Live components registered successfully! (1 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 { 
-  LiveClockComponent
-}
+// 🔥 Auto-generated Live Components Registration
+// This file is automatically generated during build time - DO NOT EDIT MANUALLY
+// Generated at: 2025-11-23T11:09:30.419Z
+
+import { LiveClockComponent } from "@/app/server/live/LiveClockComponent"
+import { LiveFileUploadComponent } from "@/app/server/live/LiveFileUploadComponent"
+import { componentRegistry } from "@/core/server/live/ComponentRegistry"
+
+// Register all components statically for production bundle
+function registerAllComponents() {
+  try {
+    // Auto-generated component registrations
+    componentRegistry.registerComponentClass('LiveClock', LiveClockComponent)
+    componentRegistry.registerComponentClass('LiveFileUpload', LiveFileUploadComponent)
+    
+    console.log('📝 Live components registered successfully! (2 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 { 
+  LiveClockComponent,
+  LiveFileUploadComponent
+}

package/core/server/live/websocket-plugin.ts

@@ -619,11 +619,17 @@ async function handleFileUploadStart(ws: any, message: FileUploadStartMessage) {
 
 async function handleFileUploadChunk(ws: any, message: FileUploadChunkMessage) {
   console.log(`📦 Receiving chunk ${message.chunkIndex + 1} for upload ${message.uploadId}`)
-  
+
   const progressResponse = await fileUploadManager.receiveChunk(message, ws)
-  
+
   if (progressResponse) {
-    ws.send(JSON.stringify(progressResponse))
+    // Add requestId to response so client can correlate it
+    const responseWithRequestId = {
+      ...progressResponse,
+      requestId: message.requestId,
+      success: true
+    }
+    ws.send(JSON.stringify(responseWithRequestId))
   } else {
     // Send error response
     const errorResponse = {
@@ -632,6 +638,7 @@ async function handleFileUploadChunk(ws: any, message: FileUploadChunkMessage) {
       uploadId: message.uploadId,
       error: 'Failed to process chunk',
       requestId: message.requestId,
+      success: false,
       timestamp: Date.now()
     }
     ws.send(JSON.stringify(errorResponse))
@@ -640,7 +647,14 @@ async function handleFileUploadChunk(ws: any, message: FileUploadChunkMessage) {
 
 async function handleFileUploadComplete(ws: any, message: FileUploadCompleteMessage) {
   console.log('✅ Completing file upload:', message.uploadId)
-  
+
   const completeResponse = await fileUploadManager.completeUpload(message)
-  ws.send(JSON.stringify(completeResponse))
+
+  // Add requestId to response so client can correlate it
+  const responseWithRequestId = {
+    ...completeResponse,
+    requestId: message.requestId
+  }
+
+  ws.send(JSON.stringify(responseWithRequestId))
 }

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

@@ -1,260 +1,69 @@
-// 🔥 FluxStack Static Files Plugin - Serve Public Files
+// 🔥 FluxStack Static Files Plugin - Serve Public Files & Uploads
 
 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'
-}
+import { mkdir } from 'fs/promises'
+import { resolve } from 'path'
+import type { Plugin, PluginContext } from '../../plugins/types'
 
 export const staticFilesPlugin: Plugin = {
   name: 'static-files',
-  description: 'Serve static files and uploads with proper caching and security',
+  description: 'Serve static files and uploads',
   author: 'FluxStack Team',
   priority: 'normal',
   category: 'core',
-  tags: ['static', 'files', 'uploads', 'public'],
-  
+  tags: ['static', 'files', 'uploads'],
+
   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'
+    const publicDir = resolve(projectRoot, 'public')
+    const uploadsDir = resolve(projectRoot, 'uploads')
+
+    // Create directories if they don't exist
+    await mkdir(publicDir, { recursive: true })
+    await mkdir(uploadsDir, { recursive: true })
+    await mkdir(resolve(uploadsDir, 'avatars'), { recursive: true })
+
+    // Helper to serve files from a directory
+    const serveFile = (baseDir: string) => ({ params, set }: any) => {
+      const requestedPath = params['*'] || ''
+      const filePath = resolve(baseDir, requestedPath)
+
+      // Path traversal protection
+      if (!filePath.startsWith(baseDir)) {
+        set.status = 400
+        return { error: 'Invalid path' }
       }
-      
-      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) => {
+
+      // Check if file exists
+      if (!existsSync(filePath)) {
+        set.status = 404
+        return { error: 'File not found' }
+      }
+
+      // Check if it's a file (not directory)
       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()) {
+        if (!statSync(filePath).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()
+      } catch {
+        set.status = 404
+        return { error: 'File not found' }
       }
-    }, {
-      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
+      // Set cache header (1 year)
+      set.headers['cache-control'] = 'public, max-age=31536000'
+
+      // Bun.file() handles: content-type, content-length, streaming
+      return Bun.file(filePath)
     }
-    context.logger.debug('📁 Static Files plugin ready', {
-      routes: [
-        config.enablePublic ? `${config.publicRoute}/*` : null,
-        config.enableUploads ? `${config.uploadsRoute}/*` : null,
-        '/api/static/info'
-      ].filter(Boolean)
+
+    // Register routes
+    context.app.get('/api/static/*', serveFile(publicDir))
+    context.app.get('/api/uploads/*', serveFile(uploadsDir))
+
+    context.logger.debug('📁 Static files plugin ready', {
+      routes: ['/api/static/*', '/api/uploads/*']
     })
   }
-}
+}

package/core/server/plugins/swagger.ts

@@ -1,34 +1,34 @@
-import { swagger } from '@elysiajs/swagger'
-import type { Plugin, PluginContext } from '@/core/plugins/types'
-
-export const swaggerPlugin: Plugin = {
-  name: 'swagger',
-  setup(context: PluginContext) {
-    context.app.use(swagger({
-      path: '/swagger',
-      documentation: {
-        info: {
-          title: 'FluxStack API',
-          version: '1.7.4',
-          description: 'Modern full-stack TypeScript framework with type-safe API endpoints'
-        },
-        tags: [
-          { 
-            name: 'Health', 
-            description: 'Health check endpoints' 
-          },
-          { 
-            name: 'Users', 
-            description: 'User management endpoints' 
-          }
-        ],
-        servers: [
-          {
-            url: `http://localhost:${context.config.server?.port || 3000}`,
-            description: 'Development server'
-          }
-        ]
-      }
-    }))
-  }
+import { swagger } from '@elysiajs/swagger'
+import type { Plugin, PluginContext } from '@/core/plugins/types'
+
+export const swaggerPlugin: Plugin = {
+  name: 'swagger',
+  setup(context: PluginContext) {
+    context.app.use(swagger({
+      path: '/swagger',
+      documentation: {
+        info: {
+          title: 'FluxStack API',
+          version: '1.7.4',
+          description: 'Modern full-stack TypeScript framework with type-safe API endpoints'
+        },
+        tags: [
+          { 
+            name: 'Health', 
+            description: 'Health check endpoints' 
+          },
+          { 
+            name: 'Users', 
+            description: 'User management endpoints' 
+          }
+        ],
+        servers: [
+          {
+            url: `http://localhost:${context.config.server?.port || 3000}`,
+            description: 'Development server'
+          }
+        ]
+      }
+    }))
+  }
 }

package/core/types/build.ts

@@ -83,6 +83,28 @@ export interface BundleOptions {
   external?: string[]
   minify?: boolean
   sourceMaps?: boolean
+  target?: string
+  executable?: ExecutableOptions
+}
+
+/**
+ * Options for compiling standalone executables
+ * Note: Cross-platform compilation is limited - executables are built for the current platform.
+ * To build for different platforms, run the build on that platform.
+ */
+export interface ExecutableOptions {
+  // Windows-specific options
+  windows?: {
+    hideConsole?: boolean
+    icon?: string
+    title?: string
+    publisher?: string
+    version?: string
+    description?: string
+    copyright?: string
+  }
+  // Additional custom build arguments
+  customArgs?: string[]
 }
 
 export interface OptimizationOptions {

package/core/types/plugin.ts

@@ -13,7 +13,15 @@ export type {
   PluginUtils,
   RequestContext,
   ResponseContext,
-  ErrorContext
+  ErrorContext,
+  BuildContext,
+  ConfigLoadContext,
+  RouteContext,
+  ValidationContext,
+  TransformContext,
+  BuildAssetContext,
+  BuildErrorContext,
+  PluginEventContext
 } from "../plugins/types"
 
 // Export Plugin as a standalone type for convenience