create-fluxstack 1.10.1 → 1.12.1

package/app/server/live/LiveUpload.ts

@@ -0,0 +1,81 @@
+// LiveUpload - Estado de upload chunked + sincronização UI
+
+import { LiveComponent } from '@core/types/types'
+
+// Componente Cliente (Ctrl+Click para navegar)
+import type { UploadDemo as _Client } from '@client/src/live/UploadDemo'
+
+export class LiveUpload extends LiveComponent<typeof LiveUpload.defaultState> {
+  static componentName = 'LiveUpload'
+  static defaultState = {
+    status: 'idle' as 'idle' | 'uploading' | 'complete' | 'error',
+    progress: 0,
+    fileName: '',
+    fileSize: 0,
+    fileType: '',
+    fileUrl: '',
+    bytesUploaded: 0,
+    totalBytes: 0,
+    error: null as string | null
+  }
+
+  async startUpload(payload: { fileName: string; fileSize: number; fileType: string }) {
+    const normalized = payload.fileName.toLowerCase()
+    if (normalized.includes('..') || normalized.includes('/') || normalized.includes('\\')) {
+      throw new Error('Invalid file name')
+    }
+
+    // All file types allowed - no extension blocking
+    // Security note: Configure allowed extensions per your application needs
+
+    this.setState({
+      status: 'uploading',
+      progress: 0,
+      fileName: payload.fileName,
+      fileSize: payload.fileSize,
+      fileType: payload.fileType,
+      fileUrl: '',
+      bytesUploaded: 0,
+      totalBytes: payload.fileSize,
+      error: null
+    })
+
+    return { success: true }
+  }
+
+  async updateProgress(payload: { progress: number; bytesUploaded: number; totalBytes: number }) {
+    const progress = Math.max(0, Math.min(100, payload.progress))
+    this.setState({
+      progress,
+      bytesUploaded: payload.bytesUploaded,
+      totalBytes: payload.totalBytes
+    })
+
+    return { success: true, progress }
+  }
+
+  async completeUpload(payload: { fileUrl: string }) {
+    this.setState({
+      status: 'complete',
+      progress: 100,
+      fileUrl: payload.fileUrl,
+      error: null
+    })
+
+    return { success: true }
+  }
+
+  async failUpload(payload: { error: string }) {
+    this.setState({
+      status: 'error',
+      error: payload.error || 'Upload failed'
+    })
+
+    return { success: true }
+  }
+
+  async reset() {
+    this.setState({ ...LiveUpload.defaultState })
+    return { success: true }
+  }
+}

package/app/server/routes/index.ts

@@ -1,5 +1,6 @@
 import { Elysia, t } from "elysia"
 import { usersRoutes } from "./users.routes"
+import { roomRoutes } from "./room.routes"
 
 export const apiRoutes = new Elysia({ prefix: "/api" })
   .get("/", () => ({ message: "🔥 Hot Reload funcionando! FluxStack API v1.4.0 ⚡" }), {
@@ -32,5 +33,6 @@ export const apiRoutes = new Elysia({ prefix: "/api" })
       description: 'Returns the current health status of the API server'
     }
   })
-  // Register users routes
+  // Register routes
   .use(usersRoutes)
+  .use(roomRoutes)

package/app/server/routes/room.routes.ts

@@ -0,0 +1,117 @@
+// 🔥 Room API Routes - Enviar mensagens para salas via HTTP
+//
+// Permite que sistemas externos (webhooks, outros serviços, etc)
+// enviem mensagens para salas de chat via API REST
+
+import { Elysia, t } from 'elysia'
+import { liveRoomManager } from '@core/server/live/LiveRoomManager'
+import { roomEvents } from '@core/server/live/RoomEventBus'
+
+export const roomRoutes = new Elysia({ prefix: '/rooms' })
+
+  // Enviar mensagem para uma sala
+  .post('/:roomId/messages', ({ params, body }) => {
+    const { roomId } = params
+    const { user, text } = body
+
+    const message = {
+      id: `api-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      user: user || 'API Bot',
+      text,
+      timestamp: Date.now()
+    }
+
+    // Emitir evento para a sala
+    // Isso vai:
+    // 1. Notificar handlers server-side via roomEvents
+    // 2. Broadcast via WebSocket para frontends
+    const notified = liveRoomManager.emitToRoom(roomId, 'message:new', message)
+
+    return {
+      success: true,
+      message,
+      notified,
+      roomId
+    }
+  }, {
+    params: t.Object({
+      roomId: t.String({ description: 'ID da sala (ex: geral, tech, random)' })
+    }),
+    body: t.Object({
+      user: t.Optional(t.String({ description: 'Nome do usuário (opcional, default: API Bot)' })),
+      text: t.String({ description: 'Texto da mensagem', minLength: 1, maxLength: 1000 })
+    }),
+    response: t.Object({
+      success: t.Boolean(),
+      message: t.Object({
+        id: t.String(),
+        user: t.String(),
+        text: t.String(),
+        timestamp: t.Number()
+      }),
+      notified: t.Number(),
+      roomId: t.String()
+    }),
+    detail: {
+      tags: ['Rooms'],
+      summary: 'Enviar mensagem para sala',
+      description: 'Envia uma mensagem para todos os usuários conectados em uma sala específica'
+    }
+  })
+
+  // Emitir evento customizado para uma sala
+  .post('/:roomId/emit', ({ params, body }) => {
+    const { roomId } = params
+    const { event, data } = body
+
+    const notified = liveRoomManager.emitToRoom(roomId, event, data)
+
+    return {
+      success: true,
+      event,
+      notified,
+      roomId
+    }
+  }, {
+    params: t.Object({
+      roomId: t.String({ description: 'ID da sala' })
+    }),
+    body: t.Object({
+      event: t.String({ description: 'Nome do evento (ex: user:typing, notification)' }),
+      data: t.Any({ description: 'Dados do evento' })
+    }),
+    response: t.Object({
+      success: t.Boolean(),
+      event: t.String(),
+      notified: t.Number(),
+      roomId: t.String()
+    }),
+    detail: {
+      tags: ['Rooms'],
+      summary: 'Emitir evento customizado',
+      description: 'Emite um evento customizado para todos os componentes em uma sala'
+    }
+  })
+
+  // Obter estatísticas das salas
+  .get('/stats', () => {
+    const roomStats = liveRoomManager.getStats()
+    const eventStats = roomEvents.getStats()
+
+    return {
+      success: true,
+      rooms: roomStats,
+      events: eventStats
+    }
+  }, {
+    response: t.Object({
+      success: t.Boolean(),
+      rooms: t.Any(),
+      events: t.Any()
+    }),
+    detail: {
+      tags: ['Rooms'],
+      summary: 'Estatísticas das salas',
+      description: 'Retorna estatísticas sobre salas ativas e eventos registrados'
+    }
+  })

package/app/server/routes/users.routes.ts

@@ -1,5 +1,6 @@
 import { Elysia, t } from 'elysia'
-import { UsersController } from '@/app/server/controllers/users.controller'
+import { UsersController } from '@app/server/controllers/users.controller'
+import type { CreateUserRequest } from '@app/shared/types'
 
 // ===== Request/Response Schemas =====
 
@@ -77,9 +78,7 @@ const ErrorResponseSchema = t.Object({
  */
 export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
   // GET /users - Get all users
-  .get('/', async () => {
-    return await UsersController.getUsers()
-  }, {
+  .get('/', async () => UsersController.getUsers(), {
     detail: {
       summary: 'Get All Users',
       description: 'Retrieves a list of all registered users',
@@ -90,19 +89,18 @@ export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
 
   // GET /users/:id - Get user by ID
   .get('/:id', async ({ params, set }) => {
-    const id = parseInt(params.id)
+    const id = Number(params.id)
 
-    // Handle invalid ID
-    if (isNaN(id)) {
+    if (!Number.isFinite(id)) {
       set.status = 400
-      return { error: 'ID inválido' }
+      return { success: false, error: 'ID invalido' }
     }
 
     const result = await UsersController.getUserById(id)
 
-    if (!result) {
+    if (!result.success) {
       set.status = 404
-      return { error: 'Usuário não encontrado' }
+      return result
     }
 
     return result
@@ -124,17 +122,17 @@ export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
 
   // POST /users - Create new user
   .post('/', async ({ body, set }) => {
-    // Validate required fields
-    if (!body.name || !body.email) {
+    const payload = body as CreateUserRequest
+
+    if (!payload.name || !payload.email) {
       set.status = 400
       return {
         success: false,
-        error: 'Nome e email são obrigatórios'
+        error: 'Nome e email sao obrigatorios'
       }
     }
 
-    // Validate name length
-    if (body.name.length < 2) {
+    if (payload.name.trim().length < 2) {
       set.status = 400
       return {
         success: false,
@@ -142,23 +140,28 @@ export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
       }
     }
 
-    // Validate email format
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
-    if (!emailRegex.test(body.email)) {
+    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$/
+    if (!emailRegex.test(payload.email)) {
       set.status = 400
       return {
         success: false,
-        error: 'Email inválido'
+        error: 'Email invalido'
       }
     }
 
-    const result = await UsersController.createUser(body)
+    const sanitizedPayload: CreateUserRequest = {
+      name: payload.name.trim(),
+      email: payload.email.trim()
+    }
+
+    const result = await UsersController.createUser(sanitizedPayload)
 
-    // If email is duplicate, still return 200 but with success: false
     if (!result.success) {
+      set.status = 409
       return result
     }
 
+    set.status = 201
     return result
   }, {
     detail: {
@@ -168,30 +171,34 @@ export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
     },
     body: CreateUserRequestSchema,
     response: {
-      200: CreateUserResponseSchema,
+      201: CreateUserResponseSchema,
       400: t.Object({
         success: t.Literal(false),
         error: t.String()
+      }),
+      409: t.Object({
+        success: t.Literal(false),
+        error: t.String()
       })
     }
   })
 
   // DELETE /users/:id - Delete user
   .delete('/:id', async ({ params, set }) => {
-    const id = parseInt(params.id)
+    const id = Number(params.id)
 
-    if (isNaN(id)) {
+    if (!Number.isFinite(id)) {
       set.status = 400
       return {
         success: false,
-        message: 'ID inválido'
+        message: 'ID invalido'
       }
     }
 
     const result = await UsersController.deleteUser(id)
 
     if (!result.success) {
-      // Don't set 404 status, just return success: false
+      set.status = 404
       return result
     }
 
@@ -210,6 +217,7 @@ export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
       400: t.Object({
         success: t.Literal(false),
         message: t.String()
-      })
+      }),
+      404: DeleteUserResponseSchema
     }
   })

package/app/shared/types/index.ts

@@ -11,8 +11,20 @@ export interface CreateUserRequest {
   email: string
 }
 
-export interface UserResponse {
+export interface UserListResponse {
+  success: true
+  users: User[]
+  count: number
+}
+
+export interface UserDetailResponse {
   success: boolean
   user?: User
+  error?: string
+}
+
+export interface MutationResponse {
+  success: boolean
   message?: string
-}
+  error?: string
+}

package/config/app.config.ts

@@ -1,62 +1,2 @@
-/**
- * Application Configuration
- * Core application metadata and global settings
- */
-
-import { defineConfig, config } from '@/core/utils/config-schema'
-import { FLUXSTACK_VERSION } from '@/core/utils/version'
-
-/**
- * App configuration schema
- * Contains only app-level metadata and global feature flags
- */
-const appConfigSchema = {
-  // App basics
-  name: config.string('APP_NAME', 'FluxStack', true),
-
-  version: {
-    type: 'string' as const,
-    env: 'APP_VERSION',
-    default: FLUXSTACK_VERSION,
-    validate: (value: string) => /^\d+\.\d+\.\d+$/.test(value) || 'Version must be semver format (e.g., 1.0.0)'
-  },
-
-  description: config.string('APP_DESCRIPTION', 'A FluxStack application'),
-
-  // Environment
-  env: config.enum('NODE_ENV', ['development', 'production', 'test'] as const, 'development', true),
-
-  // URLs
-  url: config.string('APP_URL', undefined, false),
-
-  // Security
-  trustProxy: config.boolean('TRUST_PROXY', false),
-
-  sessionSecret: {
-    type: 'string' as const,
-    env: 'SESSION_SECRET',
-    default: undefined,
-    required: false,
-    validate: (value: string) => {
-      if (!value) return true // Optional
-      if (value.length < 32) {
-        return 'Session secret must be at least 32 characters'
-      }
-      return true
-    }
-  }
-} as const
-
-export const appConfig = defineConfig(appConfigSchema)
-
-// Export type for use in other files
-export type AppConfig = typeof appConfig
-
-/**
- * Type-safe environment type
- * Use this when you need the literal type explicitly
- */
-export type Environment = typeof appConfig.env
-
-// Export default
-export default appConfig
+export { appConfig as default, appConfig } from './system/app.config'
+export type { AppConfig } from './system/app.config'

package/config/client.config.ts

@@ -1,95 +1,2 @@
-/**
- * Client & Vite Configuration
- * Declarative client, proxy and Vite dev server configuration
- */
-
-import { defineConfig, defineNestedConfig, config } from '@/core/utils/config-schema'
-import { env, helpers } from '@/core/utils/env'
-
-/**
- * Vite Dev Server Configuration
- */
-const viteSchema = {
-  port: config.number('VITE_PORT', 5173, true),
-
-  host: config.string('VITE_HOST', 'localhost'),
-
-  strictPort: config.boolean('VITE_STRICT_PORT', false),
-
-  open: config.boolean('VITE_OPEN', false),
-
-  enableLogging: config.boolean('ENABLE_VITE_PROXY_LOGS', false)
-} as const
-
-/**
- * API Proxy Configuration
- */
-const proxySchema = {
-  target: {
-    type: 'string' as const,
-    env: 'PROXY_TARGET',
-    default: helpers.getServerUrl(),
-    required: false,
-    validate: (value: string) => {
-      if (!value) return true
-      try {
-        new URL(value)
-        return true
-      } catch {
-        return 'Proxy target must be a valid URL'
-      }
-    }
-  },
-
-  changeOrigin: config.boolean('PROXY_CHANGE_ORIGIN', true),
-
-  secure: config.boolean('PROXY_SECURE', false),
-
-  ws: config.boolean('PROXY_WS', true), // WebSocket support
-
-  rewrite: {
-    type: 'object' as const,
-    env: 'PROXY_REWRITE',
-    default: {},
-    required: false
-  }
-} as const
-
-/**
- * Client Build Configuration
- */
-const buildSchema = {
-  outDir: config.string('CLIENT_OUTDIR', 'dist/client'),
-
-  sourceMaps: config.boolean('CLIENT_SOURCEMAPS', helpers.isDevelopment()),
-
-  minify: config.boolean('CLIENT_MINIFY', helpers.isProduction()),
-
-  target: config.string('CLIENT_TARGET', 'esnext'),
-
-  assetsDir: config.string('CLIENT_ASSETS_DIR', 'assets'),
-
-  cssCodeSplit: config.boolean('CLIENT_CSS_CODE_SPLIT', true),
-
-  chunkSizeWarningLimit: config.number('CLIENT_CHUNK_SIZE_WARNING', 500), // KB
-
-  emptyOutDir: config.boolean('CLIENT_EMPTY_OUTDIR', true)
-} as const
-
-/**
- * Client Configuration (nested)
- */
-export const clientConfig = defineNestedConfig({
-  vite: viteSchema,
-  proxy: proxySchema,
-  build: buildSchema
-})
-
-// Export types
-export type ViteConfig = typeof clientConfig.vite
-export type ProxyConfig = typeof clientConfig.proxy
-export type ClientBuildConfig = typeof clientConfig.build
-export type ClientConfig = typeof clientConfig
-
-// Export default
-export default clientConfig
+export { clientConfig as default, clientConfig } from './system/client.config'
+export type { ClientConfig, ViteConfig, ClientBuildConfig } from './system/client.config'

package/config/database.config.ts

@@ -1,99 +1,2 @@
-/**
- * Database Configuration
- * Laravel-style declarative config with validation
- */
-
-import { defineConfig, config } from '@/core/utils/config-schema'
-
-/**
- * Database configuration schema
- */
-export const databaseConfig = defineConfig({
-  // Connection
-  url: {
-    type: 'string',
-    env: 'DATABASE_URL',
-    default: undefined,
-    required: false,
-    validate: (value) => {
-      if (!value) return true // Optional
-      if (!value.includes('://')) {
-        return 'DATABASE_URL must be a valid connection string (e.g., postgres://...)'
-      }
-      return true
-    },
-    description: 'Full database connection URL (overrides individual settings)'
-  },
-
-  host: config.string('DB_HOST', 'localhost'),
-
-  port: config.number('DB_PORT', 5432),
-
-  database: {
-    type: 'string',
-    env: 'DB_NAME',
-    default: undefined,
-    required: false,
-    description: 'Database name'
-  },
-
-  user: {
-    type: 'string',
-    env: 'DB_USER',
-    default: undefined,
-    required: false
-  },
-
-  password: {
-    type: 'string',
-    env: 'DB_PASSWORD',
-    default: undefined,
-    required: false
-  },
-
-  // Connection pool
-  poolMin: {
-    type: 'number',
-    env: 'DB_POOL_MIN',
-    default: 2,
-    validate: (value) => value >= 0 || 'Pool min must be >= 0'
-  },
-
-  poolMax: {
-    type: 'number',
-    env: 'DB_POOL_MAX',
-    default: 10,
-    validate: (value) => value > 0 || 'Pool max must be > 0'
-  },
-
-  // SSL
-  ssl: config.boolean('DB_SSL', false),
-
-  // Timeouts
-  connectionTimeout: {
-    type: 'number',
-    env: 'DB_CONNECTION_TIMEOUT',
-    default: 30000,
-    description: 'Connection timeout in milliseconds'
-  },
-
-  queryTimeout: {
-    type: 'number',
-    env: 'DB_QUERY_TIMEOUT',
-    default: 60000,
-    description: 'Query timeout in milliseconds'
-  },
-
-  // Features
-  enableLogging: config.boolean('DB_ENABLE_LOGGING', false),
-
-  enableMigrations: config.boolean('DB_ENABLE_MIGRATIONS', true),
-
-  migrationsTable: config.string('DB_MIGRATIONS_TABLE', 'migrations')
-})
-
-// Export type
-export type DatabaseConfig = typeof databaseConfig
-
-// Export default
-export default databaseConfig
+export { databaseConfig as default, databaseConfig } from './system/database.config'
+export type { DatabaseConfig } from './system/database.config'