create-fluxstack 1.8.1 → 1.8.3

package/app/server/routes/upload.ts

@@ -1,92 +0,0 @@
-import { Elysia, t } from 'elysia'
-import { writeFile, mkdir } from 'fs/promises'
-import { existsSync } from 'fs'
-import { join, extname } from 'path'
-
-export const uploadRoutes = new Elysia({ prefix: '/upload' })
-  .post('/avatar', async ({ body }: { body: { file: File } }) => {
-    try {
-      const { file } = body
-      
-      if (!file) {
-        throw new Error('No file provided')
-      }
-
-      // Validate file type
-      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp', 'image/gif']
-      if (!allowedTypes.includes(file.type)) {
-        throw new Error('Invalid file type. Only JPEG, PNG, WebP and GIF are allowed.')
-      }
-
-      // Validate file size (5MB max)
-      const maxSize = 5 * 1024 * 1024 // 5MB
-      if (file.size > maxSize) {
-        throw new Error('File too large. Maximum size is 5MB.')
-      }
-
-      // Create uploads directory if it doesn't exist
-      const uploadsDir = join(process.cwd(), 'uploads', 'avatars')
-      if (!existsSync(uploadsDir)) {
-        await mkdir(uploadsDir, { recursive: true })
-      }
-
-      // Generate unique filename
-      const timestamp = Date.now()
-      const randomId = Math.random().toString(36).substring(2, 8)
-      const extension = extname(file.name) || '.jpg'
-      const filename = `avatar-${timestamp}-${randomId}${extension}`
-      const filepath = join(uploadsDir, filename)
-
-      // Convert file to buffer and save
-      const buffer = await file.arrayBuffer()
-      await writeFile(filepath, new Uint8Array(buffer))
-
-      // Return the URL path for the uploaded file
-      const imageUrl = `/uploads/avatars/${filename}`
-      
-      console.log('📸 Avatar uploaded successfully:', {
-        filename,
-        size: file.size,
-        type: file.type,
-        url: imageUrl
-      })
-
-      return {
-        success: true,
-        message: 'Avatar uploaded successfully',
-        imageUrl,
-        filename,
-        size: file.size,
-        type: file.type
-      }
-
-    } catch (error: any) {
-      console.error('❌ Avatar upload failed:', error.message)
-      
-      return {
-        success: false,
-        error: error.message || 'Upload failed',
-        imageUrl: null
-      }
-    }
-  }, {
-    body: t.Object({
-      file: t.File({
-        type: ['image/jpeg', 'image/jpg', 'image/png', 'image/webp', 'image/gif'],
-        maxSize: 5 * 1024 * 1024 // 5MB
-      })
-    }),
-    response: {
-      200: t.Object({
-        success: t.Boolean(),
-        message: t.Optional(t.String()),
-        error: t.Optional(t.String()),
-        imageUrl: t.Union([t.String(), t.Null()]),
-        filename: t.Optional(t.String()),
-        size: t.Optional(t.Number()),
-        type: t.Optional(t.String())
-      })
-    }
-  })
-
-  // Note: File serving is now handled by the static-files plugin at /uploads/*

package/app/server/services/NotificationService.ts

@@ -1,302 +0,0 @@
-/**
- * Notification Service
- * Handles application notifications and messaging
- */
-
-import { BaseService } from '../../../core/server/services/index.js'
-
-export interface Notification {
-    id: string
-    userId?: number
-    type: 'info' | 'success' | 'warning' | 'error'
-    title: string
-    message: string
-    data?: Record<string, any>
-    read: boolean
-    createdAt: string
-    expiresAt?: string
-}
-
-export interface CreateNotificationData {
-    userId?: number
-    type: 'info' | 'success' | 'warning' | 'error'
-    title: string
-    message: string
-    data?: Record<string, any>
-    expiresIn?: number // seconds
-}
-
-export class NotificationService extends BaseService {
-    private notifications: Notification[] = []
-
-    async initialize(): Promise<void> {
-        await super.initialize()
-
-        // Start cleanup interval for expired notifications
-        setInterval(() => {
-            this.cleanupExpiredNotifications()
-        }, 60000) // Check every minute
-
-        this.logger.info('NotificationService initialized')
-    }
-
-    /**
-     * Create a new notification
-     */
-    async createNotification(data: CreateNotificationData): Promise<Notification> {
-        return this.executeWithLogging('createNotification', async () => {
-            this.validateRequired(data, ['type', 'title', 'message'])
-
-            const notification: Notification = {
-                id: this.generateId(),
-                userId: data.userId,
-                type: data.type,
-                title: data.title.trim(),
-                message: data.message.trim(),
-                data: data.data,
-                read: false,
-                createdAt: new Date().toISOString(),
-                expiresAt: data.expiresIn
-                    ? new Date(Date.now() + data.expiresIn * 1000).toISOString()
-                    : undefined
-            }
-
-            this.notifications.push(notification)
-
-            this.logger.info('Notification created', {
-                notificationId: notification.id,
-                userId: notification.userId,
-                type: notification.type
-            })
-
-            return notification
-        }, { userId: data.userId, type: data.type })
-    }
-
-    /**
-     * Get notifications for a user
-     */
-    async getUserNotifications(
-        userId: number,
-        options: {
-            unreadOnly?: boolean
-            limit?: number
-            offset?: number
-        } = {}
-    ): Promise<{
-        notifications: Notification[]
-        total: number
-        unreadCount: number
-    }> {
-        return this.executeWithLogging('getUserNotifications', async () => {
-            let userNotifications = this.notifications.filter(n => n.userId === userId)
-
-            if (options.unreadOnly) {
-                userNotifications = userNotifications.filter(n => !n.read)
-            }
-
-            // Sort by creation date (newest first)
-            userNotifications.sort((a, b) =>
-                new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
-            )
-
-            const total = userNotifications.length
-            const unreadCount = this.notifications.filter(n =>
-                n.userId === userId && !n.read
-            ).length
-
-            // Apply pagination
-            const offset = options.offset || 0
-            const limit = options.limit || 50
-            const paginatedNotifications = userNotifications.slice(offset, offset + limit)
-
-            return {
-                notifications: paginatedNotifications,
-                total,
-                unreadCount
-            }
-        }, { userId, ...options })
-    }
-
-    /**
-     * Get global notifications (not user-specific)
-     */
-    async getGlobalNotifications(options: {
-        limit?: number
-        offset?: number
-    } = {}): Promise<{
-        notifications: Notification[]
-        total: number
-    }> {
-        return this.executeWithLogging('getGlobalNotifications', async () => {
-            let globalNotifications = this.notifications.filter(n => !n.userId)
-
-            // Sort by creation date (newest first)
-            globalNotifications.sort((a, b) =>
-                new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
-            )
-
-            const total = globalNotifications.length
-
-            // Apply pagination
-            const offset = options.offset || 0
-            const limit = options.limit || 50
-            const paginatedNotifications = globalNotifications.slice(offset, offset + limit)
-
-            return {
-                notifications: paginatedNotifications,
-                total
-            }
-        }, options)
-    }
-
-    /**
-     * Mark notification as read
-     */
-    async markAsRead(notificationId: string, userId?: number): Promise<boolean> {
-        return this.executeWithLogging('markAsRead', async () => {
-            const notification = this.notifications.find(n => n.id === notificationId)
-
-            if (!notification) {
-                return false
-            }
-
-            // Check if user has permission to mark this notification as read
-            if (notification.userId && notification.userId !== userId) {
-                throw new Error('Permission denied')
-            }
-
-            notification.read = true
-
-            this.logger.info('Notification marked as read', {
-                notificationId,
-                userId: notification.userId
-            })
-
-            return true
-        }, { notificationId, userId })
-    }
-
-    /**
-     * Mark all notifications as read for a user
-     */
-    async markAllAsRead(userId: number): Promise<number> {
-        return this.executeWithLogging('markAllAsRead', async () => {
-            const userNotifications = this.notifications.filter(n =>
-                n.userId === userId && !n.read
-            )
-
-            userNotifications.forEach(notification => {
-                notification.read = true
-            })
-
-            const count = userNotifications.length
-
-            this.logger.info('All notifications marked as read', { userId, count })
-
-            return count
-        }, { userId })
-    }
-
-    /**
-     * Delete a notification
-     */
-    async deleteNotification(notificationId: string, userId?: number): Promise<boolean> {
-        return this.executeWithLogging('deleteNotification', async () => {
-            const index = this.notifications.findIndex(n => n.id === notificationId)
-
-            if (index === -1) {
-                return false
-            }
-
-            const notification = this.notifications[index]
-
-            // Check if user has permission to delete this notification
-            if (notification.userId && notification.userId !== userId) {
-                throw new Error('Permission denied')
-            }
-
-            this.notifications.splice(index, 1)
-
-            this.logger.info('Notification deleted', {
-                notificationId,
-                userId: notification.userId
-            })
-
-            return true
-        }, { notificationId, userId })
-    }
-
-    /**
-     * Broadcast notification to all users
-     */
-    async broadcastNotification(data: Omit<CreateNotificationData, 'userId'>): Promise<Notification> {
-        return this.executeWithLogging('broadcastNotification', async () => {
-            return this.createNotification(data)
-        }, { type: data.type })
-    }
-
-    /**
-     * Get notification statistics
-     */
-    async getNotificationStats(): Promise<{
-        total: number
-        unread: number
-        byType: Record<string, number>
-        recentCount: number
-    }> {
-        return this.executeWithLogging('getNotificationStats', async () => {
-            const total = this.notifications.length
-            const unread = this.notifications.filter(n => !n.read).length
-
-            // Count by type
-            const byType: Record<string, number> = {}
-            this.notifications.forEach(n => {
-                byType[n.type] = (byType[n.type] || 0) + 1
-            })
-
-            // Recent notifications (last 24 hours)
-            const dayAgo = new Date()
-            dayAgo.setDate(dayAgo.getDate() - 1)
-            const recentCount = this.notifications.filter(n =>
-                new Date(n.createdAt) > dayAgo
-            ).length
-
-            return {
-                total,
-                unread,
-                byType,
-                recentCount
-            }
-        })
-    }
-
-    /**
-     * Cleanup expired notifications
-     */
-    private async cleanupExpiredNotifications(): Promise<void> {
-        const now = new Date()
-        const initialCount = this.notifications.length
-
-        this.notifications = this.notifications.filter(notification => {
-            if (!notification.expiresAt) {
-                return true
-            }
-
-            return new Date(notification.expiresAt) > now
-        })
-
-        const removedCount = initialCount - this.notifications.length
-
-        if (removedCount > 0) {
-            this.logger.info(`Cleaned up ${removedCount} expired notifications`)
-        }
-    }
-
-    /**
-     * Generate unique notification ID
-     */
-    private generateId(): string {
-        return `notif_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-    }
-}

package/app/server/services/UserService.ts

@@ -1,222 +0,0 @@
-/**
- * User Service
- * Handles user-related business logic
- */
-
-import { BaseService } from '../../../core/server/services/index.js'
-
-export interface User {
-  id: number
-  name: string
-  email: string
-  createdAt: string
-  updatedAt?: string
-}
-
-export interface CreateUserData {
-  name: string
-  email: string
-}
-
-export interface UpdateUserData {
-  name?: string
-  email?: string
-}
-
-export class UserService extends BaseService {
-  private users: User[] = []
-  private nextId = 1
-
-  async initialize(): Promise<void> {
-    await super.initialize()
-    
-    // Initialize with some sample data
-    this.users = [
-      {
-        id: this.nextId++,
-        name: 'John Doe',
-        email: 'john@example.com',
-        createdAt: new Date().toISOString()
-      },
-      {
-        id: this.nextId++,
-        name: 'Jane Smith',
-        email: 'jane@example.com',
-        createdAt: new Date().toISOString()
-      }
-    ]
-    
-    this.logger.info(`UserService initialized with ${this.users.length} users`)
-  }
-
-  /**
-   * Get all users
-   */
-  async getAllUsers(): Promise<User[]> {
-    return this.executeWithLogging('getAllUsers', async () => {
-      return [...this.users]
-    })
-  }
-
-  /**
-   * Get user by ID
-   */
-  async getUserById(id: number): Promise<User | null> {
-    return this.executeWithLogging('getUserById', async () => {
-      const user = this.users.find(u => u.id === id)
-      return user || null
-    }, { userId: id })
-  }
-
-  /**
-   * Get user by email
-   */
-  async getUserByEmail(email: string): Promise<User | null> {
-    return this.executeWithLogging('getUserByEmail', async () => {
-      const user = this.users.find(u => u.email === email)
-      return user || null
-    }, { email })
-  }
-
-  /**
-   * Create a new user
-   */
-  async createUser(data: CreateUserData): Promise<User> {
-    return this.executeWithLogging('createUser', async () => {
-      this.validateRequired(data, ['name', 'email'])
-      
-      // Check if email already exists
-      const existingUser = await this.getUserByEmail(data.email)
-      if (existingUser) {
-        throw new Error(`User with email '${data.email}' already exists`)
-      }
-
-      const user: User = {
-        id: this.nextId++,
-        name: data.name.trim(),
-        email: data.email.trim().toLowerCase(),
-        createdAt: new Date().toISOString()
-      }
-
-      this.users.push(user)
-      
-      this.logger.info('User created', { userId: user.id, email: user.email })
-      
-      return user
-    }, { email: data.email })
-  }
-
-  /**
-   * Update an existing user
-   */
-  async updateUser(id: number, data: UpdateUserData): Promise<User> {
-    return this.executeWithLogging('updateUser', async () => {
-      const userIndex = this.users.findIndex(u => u.id === id)
-      if (userIndex === -1) {
-        throw new Error(`User with ID ${id} not found`)
-      }
-
-      // Check email uniqueness if email is being updated
-      if (data.email) {
-        const existingUser = await this.getUserByEmail(data.email)
-        if (existingUser && existingUser.id !== id) {
-          throw new Error(`User with email '${data.email}' already exists`)
-        }
-      }
-
-      const updatedUser: User = {
-        ...this.users[userIndex],
-        ...data,
-        updatedAt: new Date().toISOString()
-      }
-
-      if (data.email) {
-        updatedUser.email = data.email.trim().toLowerCase()
-      }
-      
-      if (data.name) {
-        updatedUser.name = data.name.trim()
-      }
-
-      this.users[userIndex] = updatedUser
-      
-      this.logger.info('User updated', { userId: id })
-      
-      return updatedUser
-    }, { userId: id })
-  }
-
-  /**
-   * Delete a user
-   */
-  async deleteUser(id: number): Promise<boolean> {
-    return this.executeWithLogging('deleteUser', async () => {
-      const userIndex = this.users.findIndex(u => u.id === id)
-      if (userIndex === -1) {
-        return false
-      }
-
-      this.users.splice(userIndex, 1)
-      
-      this.logger.info('User deleted', { userId: id })
-      
-      return true
-    }, { userId: id })
-  }
-
-  /**
-   * Search users by name or email
-   */
-  async searchUsers(query: string): Promise<User[]> {
-    return this.executeWithLogging('searchUsers', async () => {
-      if (!query || query.trim().length === 0) {
-        return []
-      }
-
-      const searchTerm = query.trim().toLowerCase()
-      
-      return this.users.filter(user => 
-        user.name.toLowerCase().includes(searchTerm) ||
-        user.email.toLowerCase().includes(searchTerm)
-      )
-    }, { query })
-  }
-
-  /**
-   * Get user statistics
-   */
-  async getUserStats(): Promise<{
-    totalUsers: number
-    recentUsers: number
-    topDomains: Array<{ domain: string; count: number }>
-  }> {
-    return this.executeWithLogging('getUserStats', async () => {
-      const totalUsers = this.users.length
-      
-      // Users created in the last 7 days
-      const weekAgo = new Date()
-      weekAgo.setDate(weekAgo.getDate() - 7)
-      const recentUsers = this.users.filter(user => 
-        new Date(user.createdAt) > weekAgo
-      ).length
-
-      // Top email domains
-      const domainCounts = new Map<string, number>()
-      this.users.forEach(user => {
-        const domain = user.email.split('@')[1]
-        domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1)
-      })
-
-      const topDomains = Array.from(domainCounts.entries())
-        .map(([domain, count]) => ({ domain, count }))
-        .sort((a, b) => b.count - a.count)
-        .slice(0, 5)
-
-      return {
-        totalUsers,
-        recentUsers,
-        topDomains
-      }
-    })
-  }
-}

package/app/server/services/index.ts

@@ -1,46 +0,0 @@
-/**
- * Service Registry
- * Configures and exports all application services
- */
-
-import type { FluxStackConfig } from '../../../core/config'
-import type { Logger } from '../../../core/utils/logger/index'
-import { ServiceContainer } from '../../../core/server/services/index.js'
-import { UserService } from './UserService'
-import { NotificationService } from './NotificationService'
-
-/**
- * Create and configure the service container
- */
-export function createServiceContainer(config: FluxStackConfig, logger: Logger): ServiceContainer {
-  const container = new ServiceContainer(logger)
-
-  // Register all services
-  container.registerMany([
-    {
-      name: 'userService',
-      constructor: UserService,
-      singleton: true
-    },
-    {
-      name: 'notificationService',
-      constructor: NotificationService,
-      dependencies: [], // Could depend on userService if needed
-      singleton: true
-    }
-  ])
-
-  return container
-}
-
-// Re-export service classes and types
-export { BaseService, ServiceContainer } from '../../../core/server/services/index.js'
-export { UserService } from './UserService'
-export { NotificationService } from './NotificationService'
-
-export type { ServiceContext, ServiceDefinition } from '../../../core/server/services/index.js'
-export type { User, CreateUserData, UpdateUserData } from './UserService'
-export type { 
-  Notification, 
-  CreateNotificationData 
-} from './NotificationService'

package/app/server/types/index.ts

@@ -1 +0,0 @@
-export * from '../../shared/types'