create-fluxstack 1.7.5 → 1.8.3

package/core/cli/index.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env bun
 
-import { FluxStackBuilder } from "../build"
-import { ProjectCreator } from "../templates/create-project"
-import { getConfigSync } from "../config"
+import { FluxStackBuilder } from "@/core/build"
+import { ProjectCreator } from "@/core/templates/create-project"
+import { getConfigSync } from "@/core/config"
 import { cliRegistry } from "./command-registry"
 import { pluginDiscovery } from "./plugin-discovery"
-import { generateCommand, interactiveGenerateCommand } from "./generators/index.js"
-import { startGroup, endGroup, logBox, logInGroup } from "../utils/logger/group-logger"
+import { generateCommand, interactiveGenerateCommand } from "./generators/index"
+import { startGroup, endGroup, logBox, logInGroup } from "@/core/utils/logger/group-logger"
 
 const command = process.argv[2]
 const args = process.argv.slice(3)
@@ -138,14 +138,14 @@ Examples:
       // Grouped startup messages
       startGroup({
         title: 'FluxStack Development Server',
-        icon: '⚡',
+        icon: '',
         color: 'cyan'
       })
 
-      logInGroup(`Frontend: http://localhost:${options['frontend-port']}`, '🌐')
-      logInGroup(`Backend: http://localhost:${options.port}`, '🚀')
-      logInGroup('Backend inicia Vite programaticamente', '🔄')
-      logInGroup('Starting backend server...', '📦')
+      logInGroup(`Server: http://localhost:${options.port}`, '')
+      logInGroup(`API: http://localhost:${options.port}/api`, '')
+      logInGroup(`Swagger: http://localhost:${options.port}/swagger`, '')
+      logInGroup('Starting with hot reload...', '')
 
       endGroup()
       console.log('') // Separator line
@@ -325,7 +325,7 @@ Examples:
       }
 
       // Use the plugin generator
-      const { generatorRegistry } = await import('./generators/index.js')
+      const { generatorRegistry } = await import('./generators/index')
       const pluginGenerator = generatorRegistry.get('plugin')
 
       if (!pluginGenerator) {
@@ -356,6 +356,148 @@ Examples:
       }
     }
   })
+
+  // Frontend command (frontend-only development)
+  cliRegistry.register({
+    name: 'frontend',
+    description: 'Start frontend development server only',
+    category: 'Development',
+    usage: 'flux frontend [options]',
+    examples: [
+      'flux frontend               # Start Vite dev server on port 5173',
+      'flux frontend --port 3000   # Start on custom port'
+    ],
+    options: [
+      {
+        name: 'port',
+        short: 'p',
+        description: 'Port for frontend server',
+        type: 'number',
+        default: 5173
+      }
+    ],
+    handler: async (args, options, context) => {
+      console.log("🎨 FluxStack Frontend Development")
+      console.log(`🌐 Frontend: http://localhost:${options.port}`)
+      console.log("📦 Starting Vite dev server...")
+      console.log()
+
+      const { spawn } = await import("child_process")
+      const frontendProcess = spawn("vite", ["--config", "vite.config.ts", "--port", options.port.toString()], {
+        stdio: "inherit",
+        cwd: process.cwd()
+      })
+
+      process.on('SIGINT', () => {
+        frontendProcess.kill('SIGINT')
+        process.exit(0)
+      })
+
+      return new Promise((resolve) => {
+        frontendProcess.on('exit', resolve)
+      })
+    }
+  })
+
+  // Backend command (backend-only development)
+  cliRegistry.register({
+    name: 'backend',
+    description: 'Start backend development server only',
+    category: 'Development',
+    usage: 'flux backend [options]',
+    examples: [
+      'flux backend                # Start backend on port 3001',
+      'flux backend --port 4000    # Start on custom port'
+    ],
+    options: [
+      {
+        name: 'port',
+        short: 'p',
+        description: 'Port for backend server',
+        type: 'number',
+        default: 3001
+      }
+    ],
+    handler: async (args, options, context) => {
+      console.log("⚡ FluxStack Backend Development")
+      console.log(`🚀 API Server: http://localhost:${options.port}`)
+      console.log("📦 Starting backend with hot reload...")
+      console.log()
+
+      // Ensure backend-only.ts exists
+      const { ensureBackendEntry } = await import("../utils/regenerate-files")
+      await ensureBackendEntry()
+
+      // Start backend with Bun watch for hot reload
+      const { spawn } = await import("child_process")
+      const backendProcess = spawn("bun", ["--watch", "app/server/backend-only.ts"], {
+        stdio: "inherit",
+        cwd: process.cwd(),
+        env: {
+          ...process.env,
+          BACKEND_PORT: options.port.toString()
+        }
+      })
+
+      // Handle process cleanup
+      process.on('SIGINT', () => {
+        backendProcess.kill('SIGINT')
+        process.exit(0)
+      })
+
+      return new Promise((resolve) => {
+        backendProcess.on('exit', resolve)
+      })
+    }
+  })
+
+  // Start command (production server)
+  cliRegistry.register({
+    name: 'start',
+    description: 'Start production server',
+    category: 'Production',
+    usage: 'flux start',
+    examples: [
+      'flux start                  # Start production server from dist/'
+    ],
+    handler: async (args, options, context) => {
+      console.log("🚀 Starting FluxStack production server...")
+      const { join } = await import("path")
+      await import(join(process.cwd(), "dist", "index.js"))
+    }
+  })
+
+  // Build:frontend command (shortcut)
+  cliRegistry.register({
+    name: 'build:frontend',
+    description: 'Build frontend only (shortcut for build --frontend-only)',
+    category: 'Build',
+    usage: 'flux build:frontend',
+    examples: [
+      'flux build:frontend         # Build only frontend'
+    ],
+    handler: async (args, options, context) => {
+      const config = getConfigSync()
+      const builder = new FluxStackBuilder(config)
+      await builder.buildClient()
+    }
+  })
+
+  // Build:backend command (shortcut)
+  cliRegistry.register({
+    name: 'build:backend',
+    description: 'Build backend only (shortcut for build --backend-only)',
+    category: 'Build',
+    usage: 'flux build:backend',
+    examples: [
+      'flux build:backend          # Build only backend'
+    ],
+    handler: async (args, options, context) => {
+      const config = getConfigSync()
+      const builder = new FluxStackBuilder(config)
+      await builder.buildServer()
+    }
+  })
 }
 
 // Main CLI logic
@@ -378,185 +520,12 @@ async function main() {
     process.exit(exitCode)
     return
   }
-  
-  // Fallback to legacy command handling for backward compatibility
-  await handleLegacyCommands()
-}
-
-// Legacy command handling for backward compatibility
-async function handleLegacyCommands() {
-  switch (command) {
-  case "dev":
-    // Grouped startup messages
-    startGroup({
-      title: 'FluxStack Development Server',
-      icon: '⚡',
-      color: 'cyan'
-    })
-
-    logInGroup('Frontend: http://localhost:5173', '🌐')
-    logInGroup('Backend: http://localhost:3000', '🚀')
-    logInGroup('Backend inicia Vite programaticamente', '🔄')
-    logInGroup('Starting backend server...', '📦')
-
-    endGroup()
-    console.log('') // Separator line
-    
-    // Start only backend - it will start Vite programmatically
-    const { spawn } = await import("child_process")
-    const devProcess = spawn("bun", ["--watch", "app/server/index.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    // Handle process cleanup
-    process.on('SIGINT', () => {
-      console.log('\n🛑 Shutting down gracefully...')
-      devProcess.kill('SIGTERM')
-      setTimeout(() => {
-        devProcess.kill('SIGKILL')
-        process.exit(0)
-      }, 5000)
-    })
-    
-    devProcess.on('close', (code) => {
-      process.exit(code || 0)
-    })
-    
-    // Keep the CLI running until the child process exits
-    await new Promise((resolve) => {
-      devProcess.on('exit', resolve)
-    })
-    break
-
-  case "frontend":
-    console.log("🎨 FluxStack Frontend Development")
-    console.log("🌐 Frontend: http://localhost:5173")
-    console.log("📦 Starting Vite dev server...")
-    console.log()
-    
-    const { spawn: spawnFrontend } = await import("child_process")
-    const frontendProcess = spawnFrontend("vite", ["--config", "vite.config.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    process.on('SIGINT', () => {
-      frontendProcess.kill('SIGINT')
-      process.exit(0)
-    })
-    break
-
-  case "backend":
-    console.log("⚡ FluxStack Backend Development")
-    console.log("🚀 API Server: http://localhost:3001")
-    console.log("📦 Starting backend with hot reload...")
-    console.log()
-    
-    // Start backend with Bun watch for hot reload
-    const { spawn: spawnBackend } = await import("child_process")
-    const backendProcess = spawnBackend("bun", ["--watch", "app/server/backend-only.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    // Handle process cleanup
-    process.on('SIGINT', () => {
-      backendProcess.kill('SIGINT')
-      process.exit(0)
-    })
-    break
-
-  case "build":
-    const config = getConfigSync()
-    const builder = new FluxStackBuilder(config)
-    await builder.build()
-    break
-
-  case "build:frontend":
-    const frontendConfig = getConfigSync()
-    const frontendBuilder = new FluxStackBuilder(frontendConfig)
-    await frontendBuilder.buildClient()
-    break
-
-  case "build:backend":
-    const backendConfig = getConfigSync()
-    const backendBuilder = new FluxStackBuilder(backendConfig)
-    await backendBuilder.buildServer()
-    break
-
-  case "start":
-    console.log("🚀 Starting FluxStack production server...")
-    const { join } = await import("path")
-    await import(join(process.cwd(), "dist", "index.js"))
-    break
-
-  case "create":
-    const projectName = process.argv[3]
-    const template = process.argv[4]
-    
-    if (!projectName) {
-      console.error("❌ Please provide a project name: flux create my-app")
-      console.error()
-      console.error("Usage:")
-      console.error("  flux create <project-name> [template]")
-      console.error()
-      console.error("Templates:")
-      console.error("  basic    Basic FluxStack project (default)")
-      console.error("  full     Full-featured project with examples")
-      process.exit(1)
-    }
-
-    // Validate project name
-    if (!/^[a-zA-Z0-9-_]+$/.test(projectName)) {
-      console.error("❌ Project name can only contain letters, numbers, hyphens, and underscores")
-      process.exit(1)
-    }
-
-    try {
-      const creator = new ProjectCreator({
-        name: projectName,
-        template: template as 'basic' | 'full' || 'basic'
-      })
-      
-      await creator.create()
-    } catch (error) {
-      console.error("❌ Failed to create project:", error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-    break
 
-  default:
-    console.log(`
-⚡ FluxStack Framework CLI
-
-Usage:
-  flux dev             Start full-stack development server
-  flux frontend        Start frontend only (Vite dev server)
-  flux backend         Start backend only (API server)
-  flux build           Build both frontend and backend
-  flux build:frontend  Build frontend only
-  flux build:backend   Build backend only
-  flux start           Start production server
-  flux create          Create new project
-
-Examples:
-  flux dev                    # Full-stack development
-  flux frontend               # Frontend only (port 5173)
-  flux backend                # Backend only (port 3001)
-  flux create my-app          # Create new project
-
-Alternative commands:
-  fluxstack dev              # Same as flux dev
-  bun run dev:frontend       # Direct frontend start
-  bun run dev:backend        # Direct backend start
-
-Environment Variables:
-  FRONTEND_PORT=5173         # Frontend port
-  BACKEND_PORT=3001          # Backend port  
-  API_URL=http://localhost:3001  # API URL for frontend
-    `)
-  }
+  // Command not found - show error and help
+  console.error(`❌ Unknown command: ${command}`)
+  console.error()
+  await cliRegistry.execute('help', args)
+  process.exit(1)
 }
 
 // Run main CLI

package/core/cli/plugin-discovery.ts

@@ -1,8 +1,8 @@
 import { existsSync } from 'fs'
 import { join } from 'path'
-import type { FluxStack } from '../plugins/types'
+import type { FluxStack } from '@/core/plugins/types'
 import { cliRegistry } from './command-registry'
-import { logger } from '../utils/logger'
+import { logger } from '@/core/utils/logger'
 
 export class CliPluginDiscovery {
   private loadedPlugins = new Set<string>()
@@ -110,7 +110,7 @@ export class CliPluginDiscovery {
     }
   }
 
-  private registerPluginCommands(plugin: Plugin): void {
+  private registerPluginCommands(plugin: FluxStack.Plugin): void {
     if (!plugin.commands || this.loadedPlugins.has(plugin.name)) {
       return
     }

package/core/client/hooks/index.ts

@@ -3,5 +3,5 @@
  * FluxStack hook utilities exports
  */
 
-export { createAuthHook } from './useAuth.js'
-export type { AuthHook } from './useAuth.js'
+export { createAuthHook } from './useAuth'
+export type { AuthHook } from './useAuth'

package/core/client/hooks/state-validator.ts

@@ -1,6 +1,6 @@
 // 🔥 State Validation Utilities
 
-import type { StateValidation, StateConflict, HybridState } from '../../types/types'
+import type { StateValidation, StateConflict, HybridState } from '@/core/types/types'
 
 export class StateValidator {
   /**

package/core/client/hooks/useAuth.ts

@@ -3,7 +3,7 @@
  * Core FluxStack authentication utilities
  */
 
-import type { BaseUser, BaseUserStore } from '../state/index.js'
+import type { BaseUser, BaseUserStore } from '../state/index'
 
 /**
  * Create authentication hook for a user store

package/core/client/hooks/useChunkedUpload.ts

@@ -5,7 +5,7 @@ import type {
   FileUploadCompleteMessage,
   FileUploadProgressResponse,
   FileUploadCompleteResponse
-} from '../../types/types'
+} from '@/core/types/types'
 
 export interface ChunkedUploadOptions {
   chunkSize?: number // Default 64KB

package/core/client/hooks/useHybridLiveComponent.ts

@@ -12,7 +12,7 @@ import type {
   HybridComponentOptions,
   WebSocketMessage,
   WebSocketResponse
-} from '../../types/types'
+} from '@/core/types/types'
 
 // Client-side state persistence for reconnection
 interface PersistedComponentState {

package/core/client/hooks/useWebSocket.ts

@@ -1,7 +1,7 @@
 // 🔥 WebSocket Hook for Live Components
 
 import { useState, useEffect, useCallback, useRef } from 'react'
-import type { WebSocketMessage, WebSocketResponse } from '../../types/types'
+import type { WebSocketMessage, WebSocketResponse } from '@/core/types/types'
 
 // Re-export types for easier importing
 export type { WebSocketMessage, WebSocketResponse }

package/core/config/env.ts

@@ -3,7 +3,7 @@
  * Handles environment variable processing and precedence
  */
 
-import { env, helpers } from '../utils/env'
+import { env, helpers } from '@/core/utils/env'
 import type { FluxStackConfig, LogLevel, BuildTarget, LogFormat } from './schema'
 
 export interface EnvironmentInfo {
@@ -417,6 +417,8 @@ export function getEnvironmentRecommendations(environment: string): Partial<Flux
           target: 'bun' as const,
           outDir: 'dist',
           clean: true,
+          minify: false,
+          treeshake: false,
           optimization: {
             minify: false,
             compress: false,
@@ -459,6 +461,8 @@ export function getEnvironmentRecommendations(environment: string): Partial<Flux
           target: 'bun' as const,
           outDir: 'dist',
           clean: true,
+          minify: true,
+          treeshake: true,
           optimization: {
             minify: true,
             compress: true,

package/core/config/runtime-config.ts

@@ -6,9 +6,11 @@
 import { env, createNamespace } from '../utils/env'
 import type { FluxStackConfig } from './schema'
 import { defaultFluxStackConfig } from './schema'
-import { loggerConfig } from '../../config/logger.config'
-import { buildConfig } from '../../config/build.config'
-import { appConfig } from '../../config/app.config'
+import { loggerConfig } from '@/config/logger.config'
+import { clientConfig } from '@/config/client.config'
+import { serverConfig } from '@/config/server.config'
+import { monitoringConfig } from '@/config/monitoring.config'
+import { appConfig } from '@/config/app.config'
 
 /**
  * Runtime Configuration Builder
@@ -163,7 +165,7 @@ export const runtimeConfig = {
       .override('logging.format', 'json')
       .override('build.optimization.minify', true)
       .override('build.sourceMaps', false)
-      .override('monitoring.enabled', buildConfig.monitoringEnabled)
+      .override('monitoring.enabled', monitoringConfig.monitoring.enabled)
       .build()
   },
 
@@ -304,14 +306,14 @@ export const configHelpers = {
     return {
       port: env.VITE_PORT,
       proxy: {
-        target: buildConfig.apiUrl,
-        changeOrigin: buildConfig.proxyChangeOrigin
+        target: clientConfig.proxy.target,
+        changeOrigin: clientConfig.proxy.changeOrigin
       },
       build: {
-        outDir: buildConfig.clientBuildDir,
-        sourceMaps: buildConfig.clientSourceMaps,
-        minify: buildConfig.clientMinify,
-        target: buildConfig.clientTarget
+        outDir: clientConfig.build.outDir,
+        sourceMaps: clientConfig.build.sourceMaps,
+        minify: clientConfig.build.minify,
+        target: clientConfig.build.target
       }
     }
   }

package/core/config/schema.ts

@@ -1,8 +1,30 @@
 /**
- * Enhanced Configuration Schema for FluxStack
- * Provides comprehensive type definitions and JSON schema validation
+ * ⚠️ DEPRECATED - Enhanced Configuration Schema for FluxStack
+ *
+ * This file is DEPRECATED and maintained only for backward compatibility.
+ * Please use the new modular config system from /config instead:
+ *
+ * ✅ NEW WAY:
+ * ```ts
+ * import { appConfig, serverConfig, clientConfig } from '@/config'
+ * ```
+ *
+ * ❌ OLD WAY (DEPRECATED):
+ * ```ts
+ * import { FluxStackConfig } from '@/core/config/schema'
+ * ```
+ *
+ * The modular system provides:
+ * - Better organization (separated by domain)
+ * - Automatic validation
+ * - Type inference
+ * - Laravel-style declarative schemas
+ *
+ * This file will be removed in a future version.
+ * @deprecated Use /config modular system instead
  */
 
+
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
 export type BuildTarget = 'bun' | 'node' | 'docker'
 export type LogFormat = 'json' | 'pretty'
@@ -187,6 +209,15 @@ export interface FluxStackConfig {
   auth?: AuthConfig
   email?: EmailConfig
   storage?: StorageConfig
+  staticFiles?: {
+    publicDir?: string
+    uploadsDir?: string
+    cacheMaxAge?: number
+    enableUploads?: boolean
+    enablePublic?: boolean
+    publicRoute?: string
+    uploadsRoute?: string
+  }
 
   // Environment-specific overrides
   environments?: {

package/core/framework/server.ts

@@ -1,13 +1,14 @@
 import { Elysia } from "elysia"
-import type { FluxStackConfig, FluxStackContext } from "../types"
-import type { FluxStack, PluginContext, PluginUtils } from "../plugins/types"
-import { PluginRegistry } from "../plugins/registry"
-import { PluginManager } from "../plugins/manager"
-import { getConfigSync, getEnvironmentInfo } from "../config"
-import { logger } from "../utils/logger"
-import { displayStartupBanner, type StartupInfo } from "../utils/logger/startup-banner"
-import { createErrorHandler } from "../utils/errors/handlers"
-import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
+import type { FluxStackConfig, FluxStackContext } from "@/core/types"
+import type { FluxStack, PluginContext, PluginUtils } from "@/core/plugins/types"
+import { PluginRegistry } from "@/core/plugins/registry"
+import { PluginManager } from "@/core/plugins/manager"
+import { getConfigSync, getEnvironmentInfo } from "@/core/config"
+import { logger } from "@/core/utils/logger"
+import { displayStartupBanner, type StartupInfo } from "@/core/utils/logger/startup-banner"
+import { createErrorHandler } from "@/core/utils/errors/handlers"
+import { createTimer, formatBytes, isProduction, isDevelopment } from "@/core/utils/helpers"
+import type { Plugin } from "@/core/plugins"
 
 export class FluxStackFramework {
   private app: Elysia
@@ -18,6 +19,21 @@ export class FluxStackFramework {
   private isStarted: boolean = false
   private requestTimings: Map<string, number> = new Map()
 
+  /**
+   * Helper to safely parse request.url which might be relative or absolute
+   */
+  private 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}`)
+    }
+  }
+
   constructor(config?: Partial<FluxStackConfig>) {
     // Load the full configuration
     const fullConfig = config ? { ...getConfigSync(), ...config } : getConfigSync()
@@ -159,7 +175,7 @@ export class FluxStackFramework {
   private setupHeadHandler() {
     // Global HEAD handler to prevent Elysia's automatic HEAD conversion bug
     this.app.head("*", ({ request, set }) => {
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       // Handle API routes
       if (url.pathname.startsWith(this.context.config.server.apiPrefix)) {
@@ -233,7 +249,7 @@ export class FluxStackFramework {
     // Setup onRequest hook and onBeforeRoute hook
     this.app.onRequest(async ({ request, set }) => {
       const startTime = Date.now()
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       // Store start time for duration calculation (using request URL as key)
       const requestKey = `${request.method}-${url.pathname}-${startTime}`
@@ -274,7 +290,7 @@ export class FluxStackFramework {
 
     // Setup onResponse hook
     this.app.onAfterHandle(async ({ request, response, set }) => {
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       // Retrieve start time using the timing key
       const requestKey = set.headers['x-request-timing-key']
@@ -328,7 +344,7 @@ export class FluxStackFramework {
 
     this.app.onError(async ({ error, request, path, set }) => {
       const startTime = Date.now()
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       const errorContext = {
         request,
@@ -447,7 +463,7 @@ export class FluxStackFramework {
 
   private async handleViteProxy(errorContext: any): Promise<Response> {
     const vitePort = this.context.config.client?.port || 5173
-    const url = new URL(errorContext.request.url)
+    const url = this.parseRequestURL(errorContext.request)
 
     try {
       const viteUrl = `http://localhost:${vitePort}${url.pathname}${url.search}`