create-fluxstack 1.10.1 → 1.12.0

package/app/server/live/LiveRoomChat.ts

@@ -0,0 +1,285 @@
+// LiveRoomChat - Chat usando o sistema de salas $room
+
+import { LiveComponent, type FluxStackWebSocket } from '@core/types/types'
+
+// Componente Cliente (Ctrl+Click para navegar)
+import type { RoomChatDemo as _Client } from '@client/src/live/RoomChatDemo'
+
+// Tipos
+export interface ChatMessage {
+  id: string
+  user: string
+  text: string
+  timestamp: number
+}
+
+export interface RoomInfo {
+  id: string
+  name: string
+}
+
+export class LiveRoomChat extends LiveComponent<typeof LiveRoomChat.defaultState> {
+  static componentName = 'LiveRoomChat'
+  static defaultState = {
+    username: '',
+    activeRoom: null as string | null,
+    rooms: [] as RoomInfo[],
+    messages: {} as Record<string, ChatMessage[]>,
+    typingUsers: {} as Record<string, string[]>
+  }
+  protected roomType = 'room-chat'
+
+  private typingTimers = new Map<string, NodeJS.Timeout>()
+
+  constructor(
+    initialState: Partial<typeof LiveRoomChat.defaultState> = {},
+    ws: FluxStackWebSocket,
+    options?: { room?: string; userId?: string }
+  ) {
+    super(initialState, ws, options)
+  }
+
+  // ===== Gerenciamento de Salas =====
+
+  /**
+   * Entrar em uma sala de chat
+   */
+  async joinRoom(payload: { roomId: string; roomName?: string }) {
+    const { roomId, roomName } = payload
+
+    // Entrar na sala
+    this.$room(roomId).join()
+
+    // Escutar mensagens novas de outros usuários
+    this.$room(roomId).on('message:new', (msg: ChatMessage) => {
+      this.addMessageToState(roomId, msg)
+    })
+
+    // Escutar usuários digitando
+    this.$room(roomId).on('user:typing', (data: { user: string; typing: boolean }) => {
+      this.updateTypingUsers(roomId, data.user, data.typing)
+    })
+
+    // Atualizar lista de salas e inicializar mensagens
+    const rooms = [
+      ...this.state.rooms.filter(r => r.id !== roomId),
+      { id: roomId, name: roomName || roomId }
+    ]
+
+    this.setState({
+      rooms,
+      activeRoom: roomId,
+      messages: {
+        ...this.state.messages,
+        [roomId]: this.state.messages[roomId] || []
+      },
+      typingUsers: {
+        ...this.state.typingUsers,
+        [roomId]: []
+      }
+    })
+
+    return {
+      success: true,
+      roomId,
+      rooms: this.$rooms
+    }
+  }
+
+  private addMessageToState(roomId: string, msg: ChatMessage) {
+    const currentMessages = this.state.messages[roomId] || []
+    const newMessages = [...currentMessages, msg].slice(-100)
+
+    this.setState({
+      messages: {
+        ...this.state.messages,
+        [roomId]: newMessages
+      }
+    })
+  }
+
+  private updateTypingUsers(roomId: string, user: string, typing: boolean) {
+    const current = this.state.typingUsers[roomId] || []
+    let updated: string[]
+
+    if (typing && !current.includes(user)) {
+      updated = [...current, user]
+    } else if (!typing) {
+      updated = current.filter(u => u !== user)
+    } else {
+      return // Sem mudança
+    }
+
+    this.setState({
+      typingUsers: {
+        ...this.state.typingUsers,
+        [roomId]: updated
+      }
+    })
+  }
+
+  /**
+   * Sair de uma sala
+   */
+  async leaveRoom(payload: { roomId: string }) {
+    const { roomId } = payload
+
+    // Sair da sala
+    this.$room(roomId).leave()
+
+    // Atualizar lista
+    const rooms = this.state.rooms.filter(r => r.id !== roomId)
+    const activeRoom = this.state.activeRoom === roomId
+      ? (rooms[0]?.id || null)
+      : this.state.activeRoom
+
+    // Remover mensagens e typing da sala
+    const { [roomId]: _msgs, ...restMessages } = this.state.messages
+    const { [roomId]: _typing, ...restTyping } = this.state.typingUsers
+
+    this.setState({
+      rooms,
+      activeRoom,
+      messages: restMessages,
+      typingUsers: restTyping
+    })
+
+    return {
+      success: true,
+      rooms: this.$rooms
+    }
+  }
+
+  /**
+   * Trocar sala ativa (para UI)
+   */
+  async switchRoom(payload: { roomId: string }) {
+    if (!this.$rooms.includes(payload.roomId)) {
+      throw new Error('Not in this room')
+    }
+
+    this.setState({ activeRoom: payload.roomId })
+    return { success: true }
+  }
+
+  // ===== Mensagens =====
+
+  /**
+   * Enviar mensagem para sala ativa
+   */
+  async sendMessage(payload: { text: string; roomId?: string }) {
+    const roomId = payload.roomId || this.state.activeRoom
+    if (!roomId) throw new Error('No active room')
+
+    const text = payload.text?.trim()
+    if (!text) throw new Error('Message cannot be empty')
+    if (text.length > 1000) throw new Error('Message too long')
+
+    const message: ChatMessage = {
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      user: this.state.username || 'Anônimo',
+      text,
+      timestamp: Date.now()
+    }
+
+    // Adicionar ao meu estado local
+    this.addMessageToState(roomId, message)
+
+    // Emitir para outros na sala (eles vão receber via $room.on)
+    this.$room(roomId).emit('message:new', message)
+
+    // Parar de digitar
+    this.stopTyping({ roomId })
+
+    return { success: true, message }
+  }
+
+  /**
+   * Indicar que está digitando
+   */
+  async startTyping(payload: { roomId?: string }) {
+    const roomId = payload.roomId || this.state.activeRoom
+    if (!roomId) return { success: false }
+
+    // Emitir evento
+    this.$room(roomId).emit('user:typing', {
+      user: this.state.username,
+      typing: true
+    })
+
+    // Limpar timer anterior
+    const existingTimer = this.typingTimers.get(roomId)
+    if (existingTimer) clearTimeout(existingTimer)
+
+    // Auto-parar após 3 segundos
+    const timer = setTimeout(() => {
+      this.stopTyping({ roomId })
+    }, 3000)
+    this.typingTimers.set(roomId, timer)
+
+    return { success: true }
+  }
+
+  /**
+   * Parar de digitar
+   */
+  async stopTyping(payload: { roomId?: string }) {
+    const roomId = payload.roomId || this.state.activeRoom
+    if (!roomId) return { success: false }
+
+    // Limpar timer
+    const timer = this.typingTimers.get(roomId)
+    if (timer) {
+      clearTimeout(timer)
+      this.typingTimers.delete(roomId)
+    }
+
+    // Emitir evento
+    this.$room(roomId).emit('user:typing', {
+      user: this.state.username,
+      typing: false
+    })
+
+    return { success: true }
+  }
+
+  // ===== Configuração =====
+
+  /**
+   * Definir nome do usuário
+   */
+  async setUsername(payload: { username: string }) {
+    const username = payload.username?.trim()
+    if (!username) throw new Error('Username required')
+    if (username.length > 30) throw new Error('Username too long')
+
+    this.setState({ username })
+    return { success: true, username }
+  }
+
+  /**
+   * Obter estado de uma sala
+   */
+  async getRoomState(payload: { roomId: string }) {
+    const state = this.$room(payload.roomId).state
+    return {
+      success: true,
+      state: {
+        messages: state.messages || [],
+        typingUsers: state.typingUsers || []
+      }
+    }
+  }
+
+  // ===== Cleanup =====
+
+  public destroy() {
+    // Limpar timers
+    for (const timer of this.typingTimers.values()) {
+      clearTimeout(timer)
+    }
+    this.typingTimers.clear()
+
+    super.destroy()
+  }
+}

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
+}