create-fluxstack 1.7.5 → 1.8.3

package/app/server/live/SystemMonitorIntegration.ts

@@ -1,151 +0,0 @@
-// 🔥 System Monitor Integration - Auto-capture metrics from Live Components
-
-import { componentRegistry } from '../../../core/server/live/ComponentRegistry'
-
-export class SystemMonitorIntegration {
-  private static instance: SystemMonitorIntegration | null = null
-  private systemMonitorId: string | null = null
-  
-  private constructor() {
-    this.setupHooks()
-  }
-  
-  public static getInstance(): SystemMonitorIntegration {
-    if (!SystemMonitorIntegration.instance) {
-      SystemMonitorIntegration.instance = new SystemMonitorIntegration()
-    }
-    return SystemMonitorIntegration.instance
-  }
-  
-  // Set the system monitor component ID
-  public setSystemMonitorId(componentId: string) {
-    this.systemMonitorId = componentId
-    console.log(`📊 SystemMonitor integration activated: ${componentId}`)
-  }
-  
-  // Get system monitor component
-  private getSystemMonitor() {
-    if (!this.systemMonitorId) return null
-    return componentRegistry.getComponent(this.systemMonitorId)
-  }
-  
-  // Setup hooks to capture Live Component events
-  private setupHooks() {
-    // Override the original mountComponent method
-    const originalMountComponent = componentRegistry.mountComponent.bind(componentRegistry)
-    componentRegistry.mountComponent = async (...args) => {
-      const result = await originalMountComponent(...args)
-      
-      // Record connection event
-      this.recordConnection(args[1], 'connected')
-      
-      return result
-    }
-    
-    // Override the original unmountComponent method
-    const originalUnmountComponent = componentRegistry.unmountComponent.bind(componentRegistry)
-    componentRegistry.unmountComponent = async (componentId) => {
-      const component = componentRegistry.getComponent(componentId)
-      const componentType = component?.constructor.name || 'Unknown'
-      
-      await originalUnmountComponent(componentId)
-      
-      // Record disconnection event
-      this.recordConnection(componentType, 'disconnected')
-    }
-    
-    // Override the original rehydrateComponent method
-    const originalRehydrateComponent = componentRegistry.rehydrateComponent.bind(componentRegistry)
-    componentRegistry.rehydrateComponent = async (...args) => {
-      const result = await originalRehydrateComponent(...args)
-      
-      if (result.success) {
-        // Record rehydration event
-        this.recordConnection(args[1], 'rehydrated')
-      }
-      
-      return result
-    }
-    
-    // Override the original executeAction method
-    const originalExecuteAction = componentRegistry.executeAction.bind(componentRegistry)
-    componentRegistry.executeAction = async (componentId, action, payload) => {
-      const startTime = Date.now()
-      let success = false
-      
-      try {
-        const result = await originalExecuteAction(componentId, action, payload)
-        success = true
-        return result
-      } catch (error) {
-        success = false
-        throw error
-      } finally {
-        const responseTime = Date.now() - startTime
-        
-        // Record message event
-        this.recordMessage(action, componentId, success, responseTime)
-      }
-    }
-
-    // Setup completed - logged in auto-discovery group
-  }
-  
-  // Record a connection event
-  private recordConnection(componentType: string, status: 'connected' | 'disconnected' | 'rehydrated') {
-    const monitor = this.getSystemMonitor()
-    if (!monitor) return
-    
-    try {
-      monitor.executeAction('recordConnection', {
-        componentType,
-        status
-      }).catch(error => {
-        console.warn('⚠️ Failed to record connection event:', error.message)
-      })
-    } catch (error) {
-      console.warn('⚠️ Error recording connection event:', error)
-    }
-  }
-  
-  // Record a message event
-  private recordMessage(type: string, componentId: string, success: boolean, responseTime?: number) {
-    const monitor = this.getSystemMonitor()
-    if (!monitor) return
-    
-    try {
-      monitor.executeAction('recordMessage', {
-        type,
-        componentId,
-        success,
-        responseTime
-      }).catch(error => {
-        console.warn('⚠️ Failed to record message event:', error.message)
-      })
-    } catch (error) {
-      console.warn('⚠️ Error recording message event:', error)
-    }
-  }
-  
-  // Manually trigger metrics collection for all monitors
-  public triggerMetricsCollection() {
-    const monitor = this.getSystemMonitor()
-    if (!monitor) return
-    
-    try {
-      monitor.executeAction('collectMetrics', {}).catch(error => {
-        console.warn('⚠️ Failed to trigger metrics collection:', error.message)
-      })
-    } catch (error) {
-      console.warn('⚠️ Error triggering metrics collection:', error)
-    }
-  }
-  
-  // Get current system stats
-  public getSystemStats() {
-    return componentRegistry.getStats()
-  }
-}
-
-// Export singleton instance
-export const systemMonitorIntegration = SystemMonitorIntegration.getInstance()

package/app/server/live/UserProfileComponent.ts

@@ -1,141 +0,0 @@
-// 🔥 User Profile - Live Component
-import { LiveComponent } from "@/core/types/types";
-
-interface UserProfileState {
-  name: string;
-  email: string;
-  avatar: string;
-  status: 'online' | 'away' | 'busy' | 'offline';
-  bio: string;
-  location: string;
-  joinedDate: string;
-  followers: number;
-  following: number;
-  posts: number;
-  isEditing: boolean;
-  lastUpdated: Date; // ✅ Padronizado para Date
-  theme: 'light' | 'dark';
-  notifications: number;
-}
-
-export class UserProfileComponent extends LiveComponent<UserProfileState> {
-  constructor(initialState: UserProfileState, ws: any, options?: { room?: string; userId?: string }) {
-    const defaultState: UserProfileState = {
-      name: "João Silva",
-      email: "joao.silva@example.com",
-      avatar: "https://images.unsplash.com/photo-1472099645785-5658abf4ff4e?w=150&h=150&fit=crop&crop=face",
-      status: "online",
-      bio: "Desenvolvedor Full-Stack apaixonado por tecnologia e inovação. Sempre em busca de novos desafios!",
-      location: "São Paulo, Brasil",
-      joinedDate: "Janeiro 2023",
-      followers: 1234,
-      following: 567,
-      posts: 89,
-      isEditing: false,
-      lastUpdated: new Date(),
-      theme: "light",
-      notifications: 5,
-      ...initialState
-    };
-
-    super(defaultState, ws, options);
-    console.log('👤 UserProfile component created:', this.id, { initialState: defaultState });
-  }
-
-  async updateProfile(payload: { name?: string; bio?: string; location?: string }) {
-    const updates: Partial<UserProfileState> = {
-      lastUpdated: new Date()
-    };
-
-    if (payload.name) updates.name = payload.name;
-    if (payload.bio) updates.bio = payload.bio;
-    if (payload.location) updates.location = payload.location;
-
-    this.setState(updates);
-    console.log('👤 Profile updated:', this.id, updates);
-    return { success: true, updated: Object.keys(updates) };
-  }
-
-  async toggleStatus() {
-    const statuses: UserProfileState['status'][] = ['online', 'away', 'busy', 'offline'];
-    const currentIndex = statuses.indexOf(this.state.status);
-    const nextStatus = statuses[(currentIndex + 1) % statuses.length];
-
-    this.setState({
-      status: nextStatus,
-      lastUpdated: new Date()
-    });
-
-    console.log('👤 Status changed:', this.id, { from: this.state.status, to: nextStatus });
-    return { success: true, newStatus: nextStatus };
-  }
-
-  async toggleTheme() {
-    const newTheme = this.state.theme === 'light' ? 'dark' : 'light';
-    this.setState({
-      theme: newTheme,
-      lastUpdated: new Date()
-    });
-
-    console.log('👤 Theme changed:', this.id, { to: newTheme });
-    return { success: true, theme: newTheme };
-  }
-
-  async followUser() {
-    this.setState({
-      followers: this.state.followers + 1,
-      lastUpdated: new Date()
-    });
-
-    console.log('👤 New follower:', this.id, { followers: this.state.followers + 1 });
-    return { success: true, followers: this.state.followers };
-  }
-
-  async toggleEdit() {
-    this.setState({
-      isEditing: !this.state.isEditing,
-      lastUpdated: new Date()
-    });
-
-    console.log('👤 Edit mode toggled:', this.id, { isEditing: !this.state.isEditing });
-    return { success: true, isEditing: this.state.isEditing };
-  }
-
-  async clearNotifications() {
-    this.setState({
-      notifications: 0,
-      lastUpdated: new Date()
-    });
-
-    console.log('👤 Notifications cleared:', this.id);
-    return { success: true };
-  }
-
-  async updateAvatar(payload: { imageUrl: string }) {
-    if (!payload.imageUrl) {
-      throw new Error('Invalid image URL');
-    }
-
-    this.setState({
-      avatar: payload.imageUrl,
-      lastUpdated: new Date()
-    });
-
-    console.log('👤 Avatar updated:', this.id, {
-      newAvatar: payload.imageUrl,
-      previousAvatar: this.state.avatar
-    });
-
-    return {
-      success: true,
-      avatar: payload.imageUrl,
-      message: 'Avatar updated successfully!'
-    };
-  }
-
-  // Override destroy for cleanup
-  public destroy() {
-    console.log(`🗑️ UserProfile component ${this.id} destroyed`)
-    super.destroy()
-  }
-}

package/app/server/middleware/auth.ts

@@ -1,136 +0,0 @@
-/**
- * Authentication Middleware
- * Handles user authentication and authorization
- */
-
-import type { Context } from 'elysia'
-
-export interface AuthUser {
-  id: number
-  email: string
-  name: string
-  role: 'admin' | 'user'
-}
-
-export interface AuthContext extends Context {
-  user?: AuthUser
-}
-
-/**
- * Authentication middleware
- * Validates JWT tokens and sets user context
- */
-export const authMiddleware = {
-  name: 'auth',
-  
-  beforeHandle: async (context: AuthContext) => {
-    const authHeader = context.headers.authorization
-    
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
-      return new Response(
-        JSON.stringify({ error: 'Missing or invalid authorization header' }),
-        { status: 401, headers: { 'Content-Type': 'application/json' } }
-      )
-    }
-
-    const token = authHeader.substring(7) // Remove 'Bearer ' prefix
-    
-    try {
-      // In a real application, you would validate the JWT token here
-      // For demo purposes, we'll simulate token validation
-      const user = await validateToken(token)
-      
-      if (!user) {
-        return new Response(
-          JSON.stringify({ error: 'Invalid or expired token' }),
-          { status: 401, headers: { 'Content-Type': 'application/json' } }
-        )
-      }
-
-      // Set user in context
-      context.user = user
-    } catch (error) {
-      return new Response(
-        JSON.stringify({ error: 'Token validation failed' }),
-        { status: 401, headers: { 'Content-Type': 'application/json' } }
-      )
-    }
-  }
-}
-
-/**
- * Optional authentication middleware
- * Sets user context if token is present, but doesn't require it
- */
-export const optionalAuthMiddleware = {
-  name: 'optional-auth',
-  
-  beforeHandle: async (context: AuthContext) => {
-    const authHeader = context.headers.authorization
-    
-    if (authHeader && authHeader.startsWith('Bearer ')) {
-      const token = authHeader.substring(7)
-      
-      try {
-        const user = await validateToken(token)
-        if (user) {
-          context.user = user
-        }
-      } catch (error) {
-        // Ignore errors for optional auth
-      }
-    }
-  }
-}
-
-/**
- * Role-based authorization middleware
- */
-export const requireRole = (requiredRole: 'admin' | 'user') => ({
-  name: `require-${requiredRole}`,
-  
-  beforeHandle: async (context: AuthContext) => {
-    if (!context.user) {
-      return new Response(
-        JSON.stringify({ error: 'Authentication required' }),
-        { status: 401, headers: { 'Content-Type': 'application/json' } }
-      )
-    }
-
-    if (requiredRole === 'admin' && context.user.role !== 'admin') {
-      return new Response(
-        JSON.stringify({ error: 'Admin access required' }),
-        { status: 403, headers: { 'Content-Type': 'application/json' } }
-      )
-    }
-  }
-})
-
-/**
- * Validate JWT token (mock implementation)
- * In a real application, this would use a proper JWT library
- */
-async function validateToken(token: string): Promise<AuthUser | null> {
-  // Mock token validation
-  // In reality, you would decode and verify the JWT
-  
-  if (token === 'valid-admin-token') {
-    return {
-      id: 1,
-      email: 'admin@example.com',
-      name: 'Admin User',
-      role: 'admin'
-    }
-  }
-  
-  if (token === 'valid-user-token') {
-    return {
-      id: 2,
-      email: 'user@example.com',
-      name: 'Regular User',
-      role: 'user'
-    }
-  }
-  
-  return null
-}

package/app/server/middleware/errorHandling.ts

@@ -1,252 +0,0 @@
-/**
- * Error Handling Middleware
- * Provides centralized error handling for the application
- */
-
-import type { Context } from 'elysia'
-import { appConfig } from '@/config/app.config'
-
-export interface ErrorResponse {
-  error: string
-  message: string
-  code?: string
-  details?: any
-  timestamp: string
-  requestId?: string
-}
-
-/**
- * Custom application errors
- */
-export class AppError extends Error {
-  constructor(
-    message: string,
-    public statusCode: number = 500,
-    public code?: string,
-    public details?: any
-  ) {
-    super(message)
-    this.name = 'AppError'
-  }
-}
-
-export class ValidationError extends AppError {
-  constructor(message: string, details?: any) {
-    super(message, 400, 'VALIDATION_ERROR', details)
-    this.name = 'ValidationError'
-  }
-}
-
-export class NotFoundError extends AppError {
-  constructor(resource: string = 'Resource') {
-    super(`${resource} not found`, 404, 'NOT_FOUND')
-    this.name = 'NotFoundError'
-  }
-}
-
-export class UnauthorizedError extends AppError {
-  constructor(message: string = 'Unauthorized') {
-    super(message, 401, 'UNAUTHORIZED')
-    this.name = 'UnauthorizedError'
-  }
-}
-
-export class ForbiddenError extends AppError {
-  constructor(message: string = 'Forbidden') {
-    super(message, 403, 'FORBIDDEN')
-    this.name = 'ForbiddenError'
-  }
-}
-
-export class ConflictError extends AppError {
-  constructor(message: string, details?: any) {
-    super(message, 409, 'CONFLICT', details)
-    this.name = 'ConflictError'
-  }
-}
-
-/**
- * Error handling middleware
- */
-export const errorHandlingMiddleware = {
-  name: 'error-handling',
-  
-  onError: async (context: Context, error: Error): Promise<Response> => {
-    const requestId = context.store?.requestId || 'unknown'
-    
-    // Log the error
-    console.error('🚨 Error occurred', {
-      requestId,
-      method: context.request.method,
-      path: context.path,
-      error: error.message,
-      stack: error.stack,
-      timestamp: new Date().toISOString()
-    })
-
-    // Handle different error types
-    if (error instanceof AppError) {
-      return createErrorResponse(
-        error.statusCode,
-        error.message,
-        error.code,
-        error.details,
-        requestId
-      )
-    }
-
-    // Handle validation errors from Elysia
-    if (error.name === 'ValidationError' || error.message.includes('validation')) {
-      return createErrorResponse(
-        400,
-        'Validation failed',
-        'VALIDATION_ERROR',
-        { originalError: error.message },
-        requestId
-      )
-    }
-
-    // Handle syntax errors (malformed JSON, etc.)
-    if (error instanceof SyntaxError) {
-      return createErrorResponse(
-        400,
-        'Invalid request format',
-        'SYNTAX_ERROR',
-        undefined,
-        requestId
-      )
-    }
-
-    // Handle network/timeout errors
-    if (error.name === 'TimeoutError' || error.message.includes('timeout')) {
-      return createErrorResponse(
-        408,
-        'Request timeout',
-        'TIMEOUT_ERROR',
-        undefined,
-        requestId
-      )
-    }
-
-    // Handle database/external service errors
-    if (error.message.includes('ECONNREFUSED') || error.message.includes('connection')) {
-      return createErrorResponse(
-        503,
-        'Service temporarily unavailable',
-        'SERVICE_UNAVAILABLE',
-        undefined,
-        requestId
-      )
-    }
-
-    // Default to internal server error
-    const isProduction = appConfig.env === 'production'
-    return createErrorResponse(
-      500,
-      isProduction
-        ? 'Internal server error'
-        : error.message,
-      'INTERNAL_ERROR',
-      isProduction
-        ? undefined
-        : { stack: error.stack },
-      requestId
-    )
-  }
-}
-
-/**
- * Create standardized error response
- */
-function createErrorResponse(
-  statusCode: number,
-  message: string,
-  code?: string,
-  details?: any,
-  requestId?: string
-): Response {
-  const errorResponse: ErrorResponse = {
-    error: getErrorName(statusCode),
-    message,
-    code,
-    details,
-    timestamp: new Date().toISOString(),
-    requestId
-  }
-
-  // Remove undefined fields
-  Object.keys(errorResponse).forEach(key => {
-    if (errorResponse[key as keyof ErrorResponse] === undefined) {
-      delete errorResponse[key as keyof ErrorResponse]
-    }
-  })
-
-  return new Response(
-    JSON.stringify(errorResponse),
-    {
-      status: statusCode,
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    }
-  )
-}
-
-/**
- * Get error name from status code
- */
-function getErrorName(statusCode: number): string {
-  const errorNames: Record<number, string> = {
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    408: 'Request Timeout',
-    409: 'Conflict',
-    422: 'Unprocessable Entity',
-    429: 'Too Many Requests',
-    500: 'Internal Server Error',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout'
-  }
-
-  return errorNames[statusCode] || 'Unknown Error'
-}
-
-/**
- * Async error wrapper for route handlers
- */
-export const asyncHandler = (fn: Function) => {
-  return async (context: Context) => {
-    try {
-      return await fn(context)
-    } catch (error) {
-      throw error // Let the error middleware handle it
-    }
-  }
-}
-
-/**
- * Create error response helper
- */
-export const createError = {
-  badRequest: (message: string, details?: any) => 
-    new ValidationError(message, details),
-  
-  unauthorized: (message?: string) => 
-    new UnauthorizedError(message),
-  
-  forbidden: (message?: string) => 
-    new ForbiddenError(message),
-  
-  notFound: (resource?: string) => 
-    new NotFoundError(resource),
-  
-  conflict: (message: string, details?: any) => 
-    new ConflictError(message, details),
-  
-  internal: (message: string, details?: any) => 
-    new AppError(message, 500, 'INTERNAL_ERROR', details)
-}

package/app/server/middleware/index.ts

@@ -1,10 +0,0 @@
-/**
- * Middleware Index
- * Exports all custom middleware for the application
- */
-
-export { authMiddleware } from './auth'
-export { validationMiddleware } from './validation'
-export { rateLimitMiddleware } from './rateLimit'
-export { requestLoggingMiddleware } from './requestLogging'
-export { errorHandlingMiddleware } from './errorHandling'