create-fluxstack 1.0.22 → 1.4.0

package/core/plugins/built-in/logger/index.ts

@@ -1,180 +0,0 @@
-import type { Plugin, PluginContext, RequestContext, ResponseContext, ErrorContext } from "../../types"
-
-export const loggerPlugin: Plugin = {
-  name: "logger",
-  version: "1.0.0",
-  description: "Enhanced logging plugin for FluxStack with request/response logging",
-  author: "FluxStack Team",
-  priority: 1000, // Logger should run first
-  category: "core",
-  tags: ["logging", "monitoring"],
-  
-  configSchema: {
-    type: "object",
-    properties: {
-      logRequests: {
-        type: "boolean",
-        description: "Enable request logging"
-      },
-      logResponses: {
-        type: "boolean", 
-        description: "Enable response logging"
-      },
-      logErrors: {
-        type: "boolean",
-        description: "Enable error logging"
-      },
-      includeHeaders: {
-        type: "boolean",
-        description: "Include headers in request/response logs"
-      },
-      includeBody: {
-        type: "boolean",
-        description: "Include body in request/response logs"
-      },
-      slowRequestThreshold: {
-        type: "number",
-        minimum: 0,
-        description: "Threshold in ms to log slow requests"
-      }
-    },
-    additionalProperties: false
-  },
-  
-  defaultConfig: {
-    logRequests: process.env.ENABLE_REQUEST_LOGS === 'true',
-    logResponses: process.env.ENABLE_REQUEST_LOGS === 'true',
-    logErrors: true,
-    includeHeaders: false,
-    includeBody: false,
-    slowRequestThreshold: 1000
-  },
-
-  setup: async (context: PluginContext) => {
-    context.logger.info("Enhanced logger plugin initialized", {
-      environment: context.config.app?.name || 'fluxstack',
-      logLevel: context.config.logging.level,
-      format: context.config.logging.format
-    })
-  },
-
-  onServerStart: async (context: PluginContext) => {
-    context.logger.info("Logger plugin: Server started", {
-      port: context.config.server.port,
-      host: context.config.server.host,
-      apiPrefix: context.config.server.apiPrefix
-    })
-  },
-
-  onServerStop: async (context: PluginContext) => {
-    context.logger.info("Logger plugin: Server stopped")
-  },
-
-  onRequest: async (context: RequestContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.logRequests) return
-
-    const logData: any = {
-      method: context.method,
-      path: context.path,
-      userAgent: context.headers['user-agent'],
-      ip: context.headers['x-forwarded-for'] || context.headers['x-real-ip'] || 'unknown'
-    }
-
-    if (config.includeHeaders) {
-      logData.headers = context.headers
-    }
-
-    if (config.includeBody && context.body) {
-      logData.body = context.body
-    }
-
-    // Use a logger from context if available, otherwise create one
-    const logger = (context as any).logger || console
-    if (typeof logger.info === 'function') {
-      logger.info(`→ ${context.method} ${context.path}`, logData)
-    }
-  },
-
-  onResponse: async (context: ResponseContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.logResponses) return
-
-    const logData: any = {
-      method: context.method,
-      path: context.path,
-      statusCode: context.statusCode,
-      duration: context.duration,
-      size: context.size
-    }
-
-    if (config.includeHeaders) {
-      const headers: Record<string, string> = {}
-      context.response.headers.forEach((value, key) => {
-        headers[key] = value
-      })
-      logData.responseHeaders = headers
-    }
-
-    // Determine log level based on status code and duration
-    let logLevel = 'info'
-    if (context.statusCode >= 400) {
-      logLevel = 'warn'
-    }
-    if (context.statusCode >= 500) {
-      logLevel = 'error'
-    }
-    if (context.duration > config.slowRequestThreshold) {
-      logLevel = 'warn'
-    }
-
-    const logger = (context as any).logger || console
-    const logMessage = `← ${context.method} ${context.path} ${context.statusCode} ${context.duration}ms`
-    
-    if (typeof logger[logLevel] === 'function') {
-      logger[logLevel](logMessage, logData)
-    }
-  },
-
-  onError: async (context: ErrorContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.logErrors) return
-
-    // Skip logging for NOT_FOUND errors unless explicitly enabled
-    if (context.error.message === 'NOT_FOUND' && !process.env.ENABLE_NOT_FOUND_LOGS) {
-      return
-    }
-
-    const logData: any = {
-      method: context.method,
-      path: context.path,
-      duration: context.duration,
-      error: {
-        name: context.error.name,
-        message: context.error.message,
-        stack: context.error.stack
-      }
-    }
-
-    if (config.includeHeaders) {
-      logData.headers = context.headers
-    }
-
-    const logger = (context as any).logger || console
-    if (typeof logger.error === 'function') {
-      logger.error(`✗ ${context.method} ${context.path} - ${context.error.message}`, logData)
-    }
-  }
-}
-
-// Helper function to get plugin config from context
-function getPluginConfig(_context: any) {
-  // In a real implementation, this would get the config from the plugin context
-  // For now, return default config
-  return loggerPlugin.defaultConfig || {}
-}
-
-export default loggerPlugin

package/core/server/plugins/logger.ts

@@ -1,47 +0,0 @@
-import type { Plugin, PluginContext } from "../../types"
-import { log } from "../../utils/logger"
-
-export const loggerPlugin: Plugin = {
-  name: "logger",
-  setup: (context: PluginContext) => {
-    const logLevel = process.env.LOG_LEVEL || context.config.logging?.level || 'info'
-    const isDev = process.env.NODE_ENV === 'development'
-    
-    log.plugin("logger", "Logger plugin initialized", {
-      logLevel,
-      environment: process.env.NODE_ENV || 'development'
-    })
-    
-    // Only enable verbose request logging if explicitly requested
-    if (process.env.ENABLE_REQUEST_LOGS === 'true') {
-      // Setup logging hooks on the Elysia app
-      context.app.onRequest(({ request }: { request: Request }) => {
-        const startTime = Date.now()
-        const path = new URL(request.url).pathname
-        
-        // Store start time for duration calculation
-        ;(request as any).__startTime = startTime
-        
-        log.request(request.method, path)
-      })
-      
-      context.app.onResponse(({ request, set }: { request: Request, set: any }) => {
-        const duration = Date.now() - ((request as any).__startTime || Date.now())
-        const path = new URL(request.url).pathname
-        
-        log.request(request.method, path, set.status || 200, duration)
-      })
-    }
-    
-    // Always log errors
-    context.app.onError(({ error, request }: { error: Error, request: Request }) => {
-      const duration = Date.now() - ((request as any).__startTime || Date.now())
-      const path = new URL(request.url).pathname
-      
-      log.error(`${request.method} ${path} - ${error.message}`, {
-        duration,
-        stack: error.stack
-      })
-    })
-  }
-}

package/core/utils/env-runtime-v2.ts

@@ -1,232 +0,0 @@
-/**
- * Runtime Environment Loader V2 - Simplified API
- * Mais elegante com casting automático e acesso direto
- */
-
-/**
- * Enhanced environment variable loader with smart casting
- */
-class SmartEnvLoader {
-  private envAccessor: () => Record<string, string | undefined>
-
-  constructor() {
-    this.envAccessor = this.createDynamicAccessor()
-  }
-
-  private createDynamicAccessor(): () => Record<string, string | undefined> {
-    const globalScope = globalThis as any
-    
-    return () => {
-      // Try Bun.env first (most reliable in Bun runtime)
-      if (globalScope['Bun'] && globalScope['Bun']['env']) {
-        return globalScope['Bun']['env']
-      }
-      
-      // Fallback to process.env with dynamic access
-      if (globalScope['process'] && globalScope['process']['env']) {
-        return globalScope['process']['env']
-      }
-      
-      // Final fallback
-      const proc = eval('typeof process !== "undefined" ? process : null')
-      return proc?.env || {}
-    }
-  }
-
-  /**
-   * Smart get with automatic type conversion based on default value
-   */
-  get<T>(key: string, defaultValue?: T): T {
-    const env = this.envAccessor()
-    const value = env[key]
-    
-    if (!value || value === '') {
-      return defaultValue as T
-    }
-
-    // Auto-detect type from default value
-    if (typeof defaultValue === 'number') {
-      const parsed = parseInt(value, 10)
-      return (isNaN(parsed) ? defaultValue : parsed) as T
-    }
-
-    if (typeof defaultValue === 'boolean') {
-      return ['true', '1', 'yes', 'on'].includes(value.toLowerCase()) as T
-    }
-
-    if (Array.isArray(defaultValue)) {
-      return value.split(',').map(v => v.trim()).filter(Boolean) as T
-    }
-
-    if (typeof defaultValue === 'object' && defaultValue !== null) {
-      try {
-        return JSON.parse(value) as T
-      } catch {
-        return defaultValue
-      }
-    }
-
-    return value as T
-  }
-
-  /**
-   * Check if environment variable exists
-   */
-  has(key: string): boolean {
-    const env = this.envAccessor()
-    return key in env && env[key] !== undefined && env[key] !== ''
-  }
-
-  /**
-   * Get all environment variables
-   */
-  all(): Record<string, string> {
-    const env = this.envAccessor()
-    const result: Record<string, string> = {}
-    
-    for (const [key, value] of Object.entries(env)) {
-      if (value !== undefined && value !== '') {
-        result[key] = value
-      }
-    }
-    
-    return result
-  }
-}
-
-// Create singleton instance
-const smartEnv = new SmartEnvLoader()
-
-/**
- * Simplified env API with smart casting
- */
-export const env = {
-  /**
-   * Smart get - automatically casts based on default value type
-   * Usage:
-   *   env.get('PORT', 3000)           -> number
-   *   env.get('DEBUG', false)         -> boolean
-   *   env.get('ORIGINS', ['*'])       -> string[]
-   *   env.get('HOST', 'localhost')    -> string
-   */
-  get: <T>(key: string, defaultValue?: T): T => smartEnv.get(key, defaultValue),
-
-  /**
-   * Check if env var exists
-   */
-  has: (key: string) => smartEnv.has(key),
-
-  /**
-   * Get all env vars
-   */
-  all: () => smartEnv.all(),
-
-  // Common environment variables as properties with smart defaults
-  get NODE_ENV() { return this.get('NODE_ENV', 'development') },
-  get PORT() { return this.get('PORT', 3000) },
-  get HOST() { return this.get('HOST', 'localhost') },
-  get DEBUG() { return this.get('DEBUG', false) },
-  get LOG_LEVEL() { return this.get('LOG_LEVEL', 'info') },
-  get DATABASE_URL() { return this.get('DATABASE_URL', '') },
-  get JWT_SECRET() { return this.get('JWT_SECRET', '') },
-  get CORS_ORIGINS() { return this.get('CORS_ORIGINS', ['*']) },
-  get VITE_PORT() { return this.get('VITE_PORT', 5173) },
-  get API_PREFIX() { return this.get('API_PREFIX', '/api') },
-
-  // App specific
-  get FLUXSTACK_APP_NAME() { return this.get('FLUXSTACK_APP_NAME', 'FluxStack') },
-  get FLUXSTACK_APP_VERSION() { return this.get('FLUXSTACK_APP_VERSION', '1.0.0') },
-
-  // Monitoring
-  get ENABLE_MONITORING() { return this.get('ENABLE_MONITORING', false) },
-  get ENABLE_SWAGGER() { return this.get('ENABLE_SWAGGER', true) },
-  get ENABLE_METRICS() { return this.get('ENABLE_METRICS', false) },
-
-  // Database
-  get DB_HOST() { return this.get('DB_HOST', 'localhost') },
-  get DB_PORT() { return this.get('DB_PORT', 5432) },
-  get DB_NAME() { return this.get('DB_NAME', '') },
-  get DB_USER() { return this.get('DB_USER', '') },
-  get DB_PASSWORD() { return this.get('DB_PASSWORD', '') },
-  get DB_SSL() { return this.get('DB_SSL', false) },
-
-  // SMTP
-  get SMTP_HOST() { return this.get('SMTP_HOST', '') },
-  get SMTP_PORT() { return this.get('SMTP_PORT', 587) },
-  get SMTP_USER() { return this.get('SMTP_USER', '') },
-  get SMTP_PASSWORD() { return this.get('SMTP_PASSWORD', '') },
-  get SMTP_SECURE() { return this.get('SMTP_SECURE', false) }
-}
-
-/**
- * Create namespaced environment access
- * Usage: const db = createNamespace('DATABASE_')
- *        db.get('URL') -> reads DATABASE_URL
- */
-export function createNamespace(prefix: string) {
-  return {
-    get: <T>(key: string, defaultValue?: T): T => 
-      smartEnv.get(`${prefix}${key}`, defaultValue),
-    
-    has: (key: string) => smartEnv.has(`${prefix}${key}`),
-    
-    all: () => {
-      const allEnv = smartEnv.all()
-      const namespaced: Record<string, string> = {}
-      
-      for (const [key, value] of Object.entries(allEnv)) {
-        if (key.startsWith(prefix)) {
-          namespaced[key.slice(prefix.length)] = value
-        }
-      }
-      
-      return namespaced
-    }
-  }
-}
-
-/**
- * Environment validation
- */
-export const validate = {
-  require(keys: string[]): void {
-    const missing = keys.filter(key => !smartEnv.has(key))
-    if (missing.length > 0) {
-      throw new Error(`Missing required environment variables: ${missing.join(', ')}`)
-    }
-  },
-
-  oneOf(key: string, validValues: string[]): void {
-    const value = smartEnv.get(key, '')
-    if (value && !validValues.includes(value)) {
-      throw new Error(`${key} must be one of: ${validValues.join(', ')}, got: ${value}`)
-    }
-  }
-}
-
-/**
- * Convenience functions
- */
-export const helpers = {
-  isDevelopment: () => env.NODE_ENV === 'development',
-  isProduction: () => env.NODE_ENV === 'production',
-  isTest: () => env.NODE_ENV === 'test',
-  
-  getDatabaseUrl: () => {
-    const url = env.DATABASE_URL
-    if (url) return url
-    
-    const { DB_HOST, DB_PORT, DB_NAME, DB_USER, DB_PASSWORD } = env
-    if (DB_HOST && DB_NAME) {
-      const auth = DB_USER ? `${DB_USER}:${DB_PASSWORD}@` : ''
-      return `postgres://${auth}${DB_HOST}:${DB_PORT}/${DB_NAME}`
-    }
-    
-    return null
-  },
-
-  getServerUrl: () => `http://${env.HOST}:${env.PORT}`,
-  getClientUrl: () => `http://${env.HOST}:${env.VITE_PORT}`
-}
-
-export default env