create-fluxstack 1.0.13 → 1.0.15

package/core/server/plugins/static-files-plugin.ts

@@ -0,0 +1,232 @@
+// 🔥 FluxStack Static Files Plugin - Serve Public Files
+
+import { existsSync, statSync } from 'fs'
+import { join, extname, resolve } from 'path'
+import type { Plugin, PluginContext } from '../plugins/types'
+
+export interface StaticFilesConfig {
+  publicDir?: string // Default: 'public'
+  uploadsDir?: string // Default: 'uploads'
+  cacheMaxAge?: number // Default: 1 year in seconds
+  enableUploads?: boolean // Default: true
+  enablePublic?: boolean // Default: true
+  publicRoute?: string // Default: '/public' (can be '/static' in dev)
+  uploadsRoute?: string // Default: '/uploads'
+}
+
+export const staticFilesPlugin: Plugin = {
+  name: 'static-files',
+  version: '1.0.0',
+  description: 'Serve static files and uploads with proper caching and security',
+  author: 'FluxStack Team',
+  priority: 'normal',
+  category: 'core',
+  tags: ['static', 'files', 'uploads', 'public'],
+  
+  setup: async (context: PluginContext) => {
+    context.logger.info('📁 Setting up Static Files plugin...')
+    
+    const config: StaticFilesConfig = {
+      publicDir: 'public',
+      uploadsDir: 'uploads', 
+      cacheMaxAge: 31536000, // 1 year
+      enableUploads: true,
+      enablePublic: true,
+      publicRoute: '/api/static', // Use /api/static in dev to avoid Vite conflicts
+      uploadsRoute: '/api/uploads',
+      ...context.config.staticFiles
+    }
+    
+    const projectRoot = process.cwd()
+    const publicPath = resolve(projectRoot, config.publicDir!)
+    const uploadsPath = resolve(projectRoot, config.uploadsDir!)
+    
+    // MIME types mapping
+    const getMimeType = (extension: string): string => {
+      const mimeTypes: Record<string, string> = {
+        // Images
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg', 
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        
+        // Documents
+        '.pdf': 'application/pdf',
+        '.txt': 'text/plain',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        
+        // Web assets
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        
+        // Fonts
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.otf': 'font/otf',
+        
+        // Audio/Video
+        '.mp3': 'audio/mpeg',
+        '.mp4': 'video/mp4',
+        '.webm': 'video/webm',
+        '.ogg': 'audio/ogg'
+      }
+      
+      return mimeTypes[extension.toLowerCase()] || 'application/octet-stream'
+    }
+    
+    // Security check for path traversal
+    const isPathSafe = (filePath: string, basePath: string): boolean => {
+      const resolvedPath = resolve(basePath, filePath)
+      return resolvedPath.startsWith(basePath)
+    }
+    
+    // Generic file serving function
+    const serveFile = async (filePath: string, set: any) => {
+      try {
+        if (!existsSync(filePath)) {
+          set.status = 404
+          return { 
+            error: 'File not found',
+            path: filePath.replace(projectRoot, ''),
+            timestamp: new Date().toISOString()
+          }
+        }
+        
+        const stats = statSync(filePath)
+        if (!stats.isFile()) {
+          set.status = 404
+          return { error: 'Not a file' }
+        }
+        
+        // Set appropriate headers
+        const extension = extname(filePath).toLowerCase()
+        const mimeType = getMimeType(extension)
+        
+        set.headers['content-type'] = mimeType
+        set.headers['content-length'] = stats.size.toString()
+        set.headers['last-modified'] = stats.mtime.toUTCString()
+        set.headers['cache-control'] = `public, max-age=${config.cacheMaxAge}`
+        set.headers['etag'] = `"${stats.mtime.getTime()}-${stats.size}"`
+        
+        // Security headers for images
+        if (mimeType.startsWith('image/')) {
+          set.headers['x-content-type-options'] = 'nosniff'
+        }
+        
+        context.logger.debug(`📁 Serving file: ${filePath.replace(projectRoot, '')}`, {
+          size: stats.size,
+          mimeType,
+          lastModified: stats.mtime
+        })
+        
+        return Bun.file(filePath)
+        
+      } catch (error: any) {
+        context.logger.error('❌ File serving error:', error.message)
+        set.status = 500
+        return { error: 'Failed to serve file' }
+      }
+    }
+    
+    // Add static file routes
+    if (config.enablePublic) {
+      const publicRoutePattern = `${config.publicRoute}/*`
+      context.app.get(publicRoutePattern, ({ params, set }) => {
+        const filePath = params['*'] || ''
+        
+        if (!isPathSafe(filePath, publicPath)) {
+          set.status = 400
+          return { error: 'Invalid file path' }
+        }
+        
+        const fullPath = join(publicPath, filePath)
+        return serveFile(fullPath, set)
+      })
+      
+      context.logger.info(`📁 Public files route enabled: ${publicRoutePattern} → ${config.publicDir}`)
+    }
+    
+    if (config.enableUploads) {
+      const uploadsRoutePattern = `${config.uploadsRoute}/*`
+      context.app.get(uploadsRoutePattern, ({ params, set }) => {
+        const filePath = params['*'] || ''
+        
+        if (!isPathSafe(filePath, uploadsPath)) {
+          set.status = 400
+          return { error: 'Invalid file path' }
+        }
+        
+        const fullPath = join(uploadsPath, filePath)
+        return serveFile(fullPath, set)
+      })
+      
+      context.logger.info(`📁 Uploads route enabled: ${uploadsRoutePattern} → ${config.uploadsDir}`)
+    }
+    
+    // Static files info endpoint
+    context.app.get('/api/static/info', () => {
+      return {
+        success: true,
+        config: {
+          publicDir: config.publicDir,
+          uploadsDir: config.uploadsDir,
+          enablePublic: config.enablePublic,
+          enableUploads: config.enableUploads,
+          cacheMaxAge: config.cacheMaxAge
+        },
+        paths: {
+          publicPath,
+          uploadsPath,
+          publicUrl: config.publicRoute,
+          uploadsUrl: config.uploadsRoute
+        },
+        timestamp: new Date().toISOString()
+      }
+    })
+    
+    // Create directories if they don't exist
+    const { mkdir } = await import('fs/promises')
+    
+    if (config.enablePublic && !existsSync(publicPath)) {
+      await mkdir(publicPath, { recursive: true })
+      context.logger.info(`📁 Created public directory: ${publicPath}`)
+    }
+    
+    if (config.enableUploads && !existsSync(uploadsPath)) {
+      await mkdir(uploadsPath, { recursive: true })
+      await mkdir(join(uploadsPath, 'avatars'), { recursive: true })
+      context.logger.info(`📁 Created uploads directory: ${uploadsPath}`)
+    }
+    
+    context.logger.info('📁 Static Files plugin setup complete', {
+      publicEnabled: config.enablePublic,
+      uploadsEnabled: config.enableUploads,
+      publicPath: config.enablePublic ? publicPath : 'disabled',
+      uploadsPath: config.enableUploads ? uploadsPath : 'disabled'
+    })
+  },
+
+  onServerStart: async (context: PluginContext) => {
+    const config = {
+      enablePublic: true,
+      enableUploads: true,
+      publicRoute: '/api/static',
+      uploadsRoute: '/api/uploads',
+      ...context.config.staticFiles
+    }
+    context.logger.info('📁 Static Files plugin ready', {
+      routes: [
+        config.enablePublic ? `${config.publicRoute}/*` : null,
+        config.enableUploads ? `${config.uploadsRoute}/*` : null,
+        '/api/static/info'
+      ].filter(Boolean)
+    })
+  }
+}

package/core/server/services/BaseService.ts

@@ -0,0 +1,95 @@
+/**
+ * Base Service Class
+ * Core FluxStack service infrastructure
+ * 
+ * Provides common functionality for all services including:
+ * - Logging with service context
+ * - Configuration access
+ * - Service container integration
+ */
+
+import type { Logger } from '../../utils/logger/index.js'
+
+export interface ServiceContext {
+  config: any
+  logger: Logger
+  services?: ServiceContainer
+}
+
+export interface ServiceContainer {
+  get<T>(name: string): T
+  register<T>(name: string, service: T): void
+}
+
+export abstract class BaseService {
+  protected config: any
+  protected logger: Logger
+  protected services?: ServiceContainer
+
+  constructor(context: ServiceContext) {
+    this.config = context.config
+    this.logger = context.logger.child({ service: this.constructor.name })
+    this.services = context.services
+  }
+
+  /**
+   * Get service from container
+   */
+  protected getService<T>(name: string): T {
+    if (!this.services) {
+      throw new Error('Service container not available')
+    }
+    return this.services.get<T>(name)
+  }
+
+  /**
+   * Log service operation
+   */
+  protected logOperation(operation: string, data?: any) {
+    this.logger.info(`${operation}`, data)
+  }
+
+  /**
+   * Log service error
+   */
+  protected logError(operation: string, error: Error, data?: any) {
+    this.logger.error(`${operation} failed`, { error: error.message, data })
+  }
+
+  /**
+   * Initialize service (override in subclasses)
+   */
+  async initialize(): Promise<void> {
+    this.logger.info('Service initialized')
+  }
+
+  /**
+   * Execute operation with logging
+   */
+  protected async executeWithLogging<T>(
+    operation: string, 
+    fn: () => Promise<T> | T,
+    metadata?: any
+  ): Promise<T> {
+    this.logOperation(`Starting ${operation}`, metadata)
+    try {
+      const result = await fn()
+      this.logOperation(`Completed ${operation}`, metadata)
+      return result
+    } catch (error) {
+      this.logError(operation, error as Error, metadata)
+      throw error
+    }
+  }
+
+  /**
+   * Validate required fields
+   */
+  protected validateRequired(data: any, fields: string[]): void {
+    for (const field of fields) {
+      if (!data[field]) {
+        throw new Error(`Missing required field: ${field}`)
+      }
+    }
+  }
+}

package/core/server/services/ServiceContainer.ts

@@ -0,0 +1,144 @@
+/**
+ * Service Container
+ * Core FluxStack dependency injection container
+ * 
+ * Provides service registration, resolution, and lifecycle management
+ */
+
+import type { Logger } from '../../utils/logger/index.js'
+
+export interface ServiceDefinition {
+  factory: (container: ServiceContainer) => any
+  singleton?: boolean
+  dependencies?: string[]
+}
+
+export class ServiceContainer {
+  private services = new Map<string, any>()
+  private definitions = new Map<string, ServiceDefinition>()
+  private singletons = new Map<string, any>()
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'ServiceContainer' })
+  }
+
+  /**
+   * Register a service definition
+   */
+  register<T>(name: string, definition: ServiceDefinition | T): void {
+    if (typeof definition === 'object' && definition !== null && 'factory' in definition) {
+      this.definitions.set(name, definition as ServiceDefinition)
+      this.logger.debug(`Registered service definition: ${name}`)
+    } else {
+      this.services.set(name, definition)
+      this.logger.debug(`Registered service instance: ${name}`)
+    }
+  }
+
+  /**
+   * Get a service instance
+   */
+  get<T>(name: string): T {
+    // Check for direct service instance
+    if (this.services.has(name)) {
+      return this.services.get(name) as T
+    }
+
+    // Check for singleton instance
+    if (this.singletons.has(name)) {
+      return this.singletons.get(name) as T
+    }
+
+    // Check for service definition
+    const definition = this.definitions.get(name)
+    if (!definition) {
+      throw new Error(`Service not found: ${name}`)
+    }
+
+    // Resolve dependencies first
+    if (definition.dependencies) {
+      for (const dep of definition.dependencies) {
+        if (!this.has(dep)) {
+          throw new Error(`Dependency not found: ${dep} (required by ${name})`)
+        }
+      }
+    }
+
+    // Create service instance
+    const instance = definition.factory(this)
+
+    // Store singleton if needed
+    if (definition.singleton) {
+      this.singletons.set(name, instance)
+    }
+
+    this.logger.debug(`Created service instance: ${name}`)
+    return instance as T
+  }
+
+  /**
+   * Check if service exists
+   */
+  has(name: string): boolean {
+    return this.services.has(name) || 
+           this.definitions.has(name) || 
+           this.singletons.has(name)
+  }
+
+  /**
+   * Remove a service
+   */
+  remove(name: string): void {
+    this.services.delete(name)
+    this.definitions.delete(name)
+    this.singletons.delete(name)
+    this.logger.debug(`Removed service: ${name}`)
+  }
+
+  /**
+   * Get all registered service names
+   */
+  getServiceNames(): string[] {
+    const names = new Set<string>()
+    
+    // Use Array.from to avoid iterator issues
+    Array.from(this.services.keys()).forEach(name => names.add(name))
+    Array.from(this.definitions.keys()).forEach(name => names.add(name))
+    Array.from(this.singletons.keys()).forEach(name => names.add(name))
+    
+    return Array.from(names)
+  }
+
+  /**
+   * Register multiple services at once
+   */
+  registerMany(services: Array<{
+    name: string
+    constructor: any
+    dependencies?: string[]
+    singleton?: boolean
+  }>): void {
+    for (const service of services) {
+      this.register(service.name, {
+        factory: (container) => new service.constructor({
+          config: {},
+          logger: this.logger,
+          services: container
+        }),
+        dependencies: service.dependencies,
+        singleton: service.singleton
+      })
+    }
+  }
+
+  /**
+   * Clear all services
+   */
+  clear(): void {
+    this.services.clear()
+    this.definitions.clear()
+    this.singletons.clear()
+    this.logger.debug('Cleared all services')
+  }
+}

package/core/server/services/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Core Server Services
+ * FluxStack service infrastructure exports
+ */
+
+export { BaseService } from './BaseService.js'
+export { ServiceContainer } from './ServiceContainer.js'
+export type { ServiceContext, ServiceContainer as IServiceContainer } from './BaseService.js'
+export type { ServiceDefinition } from './ServiceContainer.js'