create-fluxstack 1.8.1 → 1.8.3

package/core/cli/generators/route.ts

@@ -1,6 +1,6 @@
-import type { Generator } from "./index.js"
-import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
-import { templateEngine } from "./template-engine.js"
+import type { Generator } from "./index"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types"
+import { templateEngine } from "./template-engine"
 
 export class RouteGenerator implements Generator {
   name = 'route'
@@ -54,15 +54,23 @@ export class RouteGenerator implements Generator {
           path: 'app/server/routes/{{kebabName}}.routes.ts',
           content: `import { Elysia, t } from 'elysia'
 import { {{pascalName}}Controller } from '../controllers/{{kebabName}}.controller'
-import { errorHandler } from '../../../core/utils/errors/middleware'
-import { logger } from '../../../core/utils/logger'
+import { errorHandler } from '@/core/utils/errors/middleware'
+import { logger } from '@/core/utils/logger'
 
 const controller = new {{pascalName}}Controller()
 
 export const {{camelName}}Routes = new Elysia({ prefix: '/api/{{kebabName}}s' })
   .use(errorHandler)
   .onBeforeHandle(({ request }) => {
-    logger.request(request.method, new URL(request.url).pathname)
+    const url = (() => {
+      try {
+        return new URL(request.url)
+      } catch {
+        const host = request.headers.get('host') || 'localhost'
+        return new URL(request.url, \`http://\${host}\`)
+      }
+    })()
+    logger.request(request.method, url.pathname)
   })
   .get('/', async () => {
     return await controller.getAll()
@@ -300,16 +308,24 @@ export const {{camelName}}Routes = new Elysia({ prefix: '/api/{{kebabName}}s' })
           path: 'app/server/routes/auth.routes.ts',
           content: `import { Elysia, t } from 'elysia'
 import { AuthController } from '../controllers/auth.controller'
-import { errorHandler } from '../../../core/utils/errors/middleware'
+import { errorHandler } from '@/core/utils/errors/middleware'
 import { authMiddleware } from '../middleware/auth.middleware'
-import { logger } from '../../../core/utils/logger'
+import { logger } from '@/core/utils/logger'
 
 const controller = new AuthController()
 
 export const authRoutes = new Elysia({ prefix: '/api/auth' })
   .use(errorHandler)
   .onBeforeHandle(({ request }) => {
-    logger.request(request.method, new URL(request.url).pathname)
+    const url = (() => {
+      try {
+        return new URL(request.url)
+      } catch {
+        const host = request.headers.get('host') || 'localhost'
+        return new URL(request.url, \`http://\${host}\`)
+      }
+    })()
+    logger.request(request.method, url.pathname)
   })
   .post('/register', async ({ body }) => {
     return await controller.register({ body })
@@ -456,8 +472,8 @@ export const authRoutes = new Elysia({ prefix: '/api/auth' })
         {
           path: 'app/server/middleware/auth.middleware.ts',
           content: `import { Context } from 'elysia'
-import { UnauthorizedError } from '../../../core/utils/errors'
-import { logger } from '../../../core/utils/logger'
+import { UnauthorizedError } from '@/core/utils/errors'
+import { logger } from '@/core/utils/logger'
 
 // JWT verification function (implement based on your JWT library)
 async function verifyJWT(token: string): Promise<any> {

package/core/cli/generators/service.ts

@@ -1,6 +1,6 @@
-import type { Generator } from "./index.js"
-import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
-import { templateEngine } from "./template-engine.js"
+import type { Generator } from "./index"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types"
+import { templateEngine } from "./template-engine"
 
 export class ServiceGenerator implements Generator {
   name = 'service'
@@ -54,8 +54,8 @@ export class ServiceGenerator implements Generator {
           path: 'app/server/services/{{kebabName}}.service.ts',
           content: `import { {{pascalName}}, Create{{pascalName}}, Update{{pascalName}} } from '../schemas/{{kebabName}}.schema'
 import { {{pascalName}}Repository } from '../repositories/{{kebabName}}.repository'
-import { ValidationError, NotFoundError } from '../../../core/utils/errors'
-import { logger } from '../../../core/utils/logger'
+import { ValidationError, NotFoundError } from '@/core/utils/errors'
+import { logger } from '@/core/utils/logger'
 
 export class {{pascalName}}Service {
   private repository: {{pascalName}}Repository

package/core/cli/generators/template-engine.ts

@@ -1,4 +1,4 @@
-import type { GeneratorContext, GeneratorOptions, Template, TemplateFile, GeneratedFile, TemplateProcessor } from "./types.js"
+import type { GeneratorContext, GeneratorOptions, Template, TemplateFile, GeneratedFile, TemplateProcessor } from "./types"
 import { join, dirname } from "path"
 import { mkdir, writeFile, readFile, stat } from "fs/promises"
 import { existsSync } from "fs"

package/core/cli/generators/types.ts

@@ -1,5 +1,5 @@
 import type { FluxStackConfig } from "../../config/schema"
-import type { Logger } from "../../utils/logger/index"
+import type { Logger } from "@/core/utils/logger/index"
 import type { PluginUtils } from "../../plugins/types"
 
 export interface GeneratorContext {

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,189 +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()
-
-    // Ensure backend-only.ts exists
-    const { ensureBackendEntry } = await import("../utils/regenerate-files")
-    await ensureBackendEntry()
-
-    // 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 {

package/core/config/runtime-config.ts

@@ -6,11 +6,11 @@
 import { env, createNamespace } from '../utils/env'
 import type { FluxStackConfig } from './schema'
 import { defaultFluxStackConfig } from './schema'
-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'
+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

package/core/config/schema.ts

@@ -209,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?: {