create-fluxstack 1.0.0 → 1.0.2

package/core/utils/env-runtime.ts

@@ -1,252 +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 number value
-   */
-  num: (key: string, defaultValue?: number) => Number(smartEnv.get(key, defaultValue?.toString() || '0')),
-
-  /**
-   * Get boolean value
-   */
-  bool: (key: string, defaultValue?: boolean) => smartEnv.get(key, defaultValue?.toString() || 'false') === 'true',
-
-  /**
-   * Get array value
-   */
-  array: (key: string, defaultValue?: string[]) => smartEnv.get(key, defaultValue?.join(',') || '').split(',').filter(Boolean),
-
-  /**
-   * 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
-
-// Legacy exports for compatibility
-export const runtimeEnv = env
-export const envValidation = validate
-export const createEnvNamespace = createNamespace

package/core/utils/errors/codes.ts

@@ -1,115 +0,0 @@
-export const ERROR_CODES = {
-  // Validation errors (400)
-  VALIDATION_ERROR: 'VALIDATION_ERROR',
-  INVALID_INPUT: 'INVALID_INPUT',
-  MISSING_REQUIRED_FIELD: 'MISSING_REQUIRED_FIELD',
-  INVALID_FORMAT: 'INVALID_FORMAT',
-  
-  // Authentication errors (401)
-  UNAUTHORIZED: 'UNAUTHORIZED',
-  INVALID_TOKEN: 'INVALID_TOKEN',
-  TOKEN_EXPIRED: 'TOKEN_EXPIRED',
-  INVALID_CREDENTIALS: 'INVALID_CREDENTIALS',
-  
-  // Authorization errors (403)
-  FORBIDDEN: 'FORBIDDEN',
-  INSUFFICIENT_PERMISSIONS: 'INSUFFICIENT_PERMISSIONS',
-  ACCESS_DENIED: 'ACCESS_DENIED',
-  
-  // Not found errors (404)
-  NOT_FOUND: 'NOT_FOUND',
-  RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
-  ENDPOINT_NOT_FOUND: 'ENDPOINT_NOT_FOUND',
-  
-  // Conflict errors (409)
-  CONFLICT: 'CONFLICT',
-  RESOURCE_ALREADY_EXISTS: 'RESOURCE_ALREADY_EXISTS',
-  DUPLICATE_ENTRY: 'DUPLICATE_ENTRY',
-  
-  // Server errors (500)
-  INTERNAL_ERROR: 'INTERNAL_ERROR',
-  INTERNAL_SERVER_ERROR: 'INTERNAL_SERVER_ERROR',
-  DATABASE_ERROR: 'DATABASE_ERROR',
-  EXTERNAL_SERVICE_ERROR: 'EXTERNAL_SERVICE_ERROR',
-  
-  // Service unavailable (503)
-  SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
-  MAINTENANCE_MODE: 'MAINTENANCE_MODE',
-  RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
-  
-  // Plugin errors
-  PLUGIN_ERROR: 'PLUGIN_ERROR',
-  PLUGIN_NOT_FOUND: 'PLUGIN_NOT_FOUND',
-  PLUGIN_INITIALIZATION_ERROR: 'PLUGIN_INITIALIZATION_ERROR',
-  
-  // Configuration errors
-  CONFIG_ERROR: 'CONFIG_ERROR',
-  INVALID_CONFIG: 'INVALID_CONFIG',
-  MISSING_CONFIG: 'MISSING_CONFIG',
-  
-  // Build errors
-  BUILD_ERROR: 'BUILD_ERROR',
-  COMPILATION_ERROR: 'COMPILATION_ERROR',
-  BUNDLING_ERROR: 'BUNDLING_ERROR'
-} as const
-
-export type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES]
-
-export const getErrorMessage = (code: ErrorCode): string => {
-  const messages: Record<ErrorCode, string> = {
-    // Validation errors
-    VALIDATION_ERROR: 'Validation failed',
-    INVALID_INPUT: 'Invalid input provided',
-    MISSING_REQUIRED_FIELD: 'Required field is missing',
-    INVALID_FORMAT: 'Invalid format',
-    
-    // Authentication errors
-    UNAUTHORIZED: 'Authentication required',
-    INVALID_TOKEN: 'Invalid authentication token',
-    TOKEN_EXPIRED: 'Authentication token has expired',
-    INVALID_CREDENTIALS: 'Invalid credentials provided',
-    
-    // Authorization errors
-    FORBIDDEN: 'Access forbidden',
-    INSUFFICIENT_PERMISSIONS: 'Insufficient permissions',
-    ACCESS_DENIED: 'Access denied',
-    
-    // Not found errors
-    NOT_FOUND: 'Resource not found',
-    RESOURCE_NOT_FOUND: 'Requested resource not found',
-    ENDPOINT_NOT_FOUND: 'API endpoint not found',
-    
-    // Conflict errors
-    CONFLICT: 'Resource conflict',
-    RESOURCE_ALREADY_EXISTS: 'Resource already exists',
-    DUPLICATE_ENTRY: 'Duplicate entry',
-    
-    // Server errors
-    INTERNAL_ERROR: 'Internal server error',
-    INTERNAL_SERVER_ERROR: 'Internal server error',
-    DATABASE_ERROR: 'Database operation failed',
-    EXTERNAL_SERVICE_ERROR: 'External service error',
-    
-    // Service unavailable
-    SERVICE_UNAVAILABLE: 'Service temporarily unavailable',
-    MAINTENANCE_MODE: 'Service is under maintenance',
-    RATE_LIMIT_EXCEEDED: 'Rate limit exceeded',
-    
-    // Plugin errors
-    PLUGIN_ERROR: 'Plugin error',
-    PLUGIN_NOT_FOUND: 'Plugin not found',
-    PLUGIN_INITIALIZATION_ERROR: 'Plugin initialization failed',
-    
-    // Configuration errors
-    CONFIG_ERROR: 'Configuration error',
-    INVALID_CONFIG: 'Invalid configuration',
-    MISSING_CONFIG: 'Missing configuration',
-    
-    // Build errors
-    BUILD_ERROR: 'Build error',
-    COMPILATION_ERROR: 'Compilation failed',
-    BUNDLING_ERROR: 'Bundling failed'
-  }
-  
-  return messages[code] || 'Unknown error'
-}

package/core/utils/errors/handlers.ts

@@ -1,63 +0,0 @@
-import { FluxStackError } from "./index"
-import type { Logger } from "../logger/index"
-
-export interface ErrorHandlerContext {
-  logger: Logger
-  isDevelopment: boolean
-  request?: Request
-  path?: string
-}
-
-export const errorHandler = (error: Error, context: ErrorHandlerContext) => {
-  const { logger, isDevelopment, request, path } = context
-  
-  if (error instanceof FluxStackError) {
-    // Log FluxStack errors with appropriate level
-    const logLevel = error.statusCode >= 500 ? 'error' : 'warn'
-    logger[logLevel](error.message, {
-      code: error.code,
-      statusCode: error.statusCode,
-      context: error.context,
-      path,
-      method: request?.method,
-      stack: isDevelopment ? error.stack : undefined
-    })
-    
-    return {
-      error: {
-        message: error.message,
-        code: error.code,
-        statusCode: error.statusCode,
-        ...(error.context && { details: error.context }),
-        ...(isDevelopment && { stack: error.stack })
-      }
-    }
-  }
-  
-  // Handle unknown errors - skip logging for NOT_FOUND unless explicitly enabled
-  if (error.message === 'NOT_FOUND' && !process.env.ENABLE_NOT_FOUND_LOGS) {
-    // Skip logging NOT_FOUND errors to reduce noise
-  } else {
-    logger.error('Unhandled error', { 
-      error: error.message, 
-      stack: error.stack,
-      path,
-      method: request?.method
-    })
-  }
-  
-  return {
-    error: {
-      message: isDevelopment ? error.message : 'Internal server error',
-      code: 'INTERNAL_ERROR',
-      statusCode: 500,
-      ...(isDevelopment && { stack: error.stack })
-    }
-  }
-}
-
-export const createErrorHandler = (context: Omit<ErrorHandlerContext, 'request' | 'path'>) => {
-  return (error: Error, request?: Request, path?: string) => {
-    return errorHandler(error, { ...context, request, path })
-  }
-}

package/core/utils/errors/index.ts

@@ -1,81 +0,0 @@
-export class FluxStackError extends Error {
-  public readonly code: string
-  public readonly statusCode: number
-  public readonly context?: any
-  public readonly timestamp: Date
-
-  constructor(
-    message: string,
-    code: string,
-    statusCode: number = 500,
-    context?: any
-  ) {
-    super(message)
-    this.name = 'FluxStackError'
-    this.code = code
-    this.statusCode = statusCode
-    this.context = context
-    this.timestamp = new Date()
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      statusCode: this.statusCode,
-      context: this.context,
-      timestamp: this.timestamp,
-      stack: this.stack
-    }
-  }
-}
-
-export class ValidationError extends FluxStackError {
-  constructor(message: string, context?: any) {
-    super(message, 'VALIDATION_ERROR', 400, context)
-    this.name = 'ValidationError'
-  }
-}
-
-export class NotFoundError extends FluxStackError {
-  constructor(resource: string, context?: any) {
-    super(`${resource} not found`, 'NOT_FOUND', 404, context)
-    this.name = 'NotFoundError'
-  }
-}
-
-export class UnauthorizedError extends FluxStackError {
-  constructor(message: string = 'Unauthorized', context?: any) {
-    super(message, 'UNAUTHORIZED', 401, context)
-    this.name = 'UnauthorizedError'
-  }
-}
-
-export class ForbiddenError extends FluxStackError {
-  constructor(message: string = 'Forbidden', context?: any) {
-    super(message, 'FORBIDDEN', 403, context)
-    this.name = 'ForbiddenError'
-  }
-}
-
-export class ConflictError extends FluxStackError {
-  constructor(message: string, context?: any) {
-    super(message, 'CONFLICT', 409, context)
-    this.name = 'ConflictError'
-  }
-}
-
-export class InternalServerError extends FluxStackError {
-  constructor(message: string = 'Internal server error', context?: any) {
-    super(message, 'INTERNAL_SERVER_ERROR', 500, context)
-    this.name = 'InternalServerError'
-  }
-}
-
-export class ServiceUnavailableError extends FluxStackError {
-  constructor(message: string = 'Service unavailable', context?: any) {
-    super(message, 'SERVICE_UNAVAILABLE', 503, context)
-    this.name = 'ServiceUnavailableError'
-  }
-}

package/core/utils/helpers.ts

@@ -1,180 +0,0 @@
-/**
- * General utility functions for FluxStack
- */
-
-export const formatBytes = (bytes: number, decimals: number = 2): string => {
-  if (bytes === 0) return '0 Bytes'
-
-  const k = 1024
-  const dm = decimals < 0 ? 0 : decimals
-  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
-
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i]
-}
-
-export const createTimer = (label: string) => {
-  const start = Date.now()
-  
-  return {
-    end: (): number => {
-      const duration = Date.now() - start
-      return duration
-    },
-    label
-  }
-}
-
-export const delay = (ms: number): Promise<void> => {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-export const retry = async <T>(
-  fn: () => Promise<T>,
-  maxAttempts: number = 3,
-  delayMs: number = 1000
-): Promise<T> => {
-  let lastError: Error
-  
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await fn()
-    } catch (error) {
-      lastError = error as Error
-      
-      if (attempt === maxAttempts) {
-        throw lastError
-      }
-      
-      await delay(delayMs * attempt) // Exponential backoff
-    }
-  }
-  
-  throw lastError!
-}
-
-export const debounce = <T extends (...args: any[]) => any>(
-  func: T,
-  wait: number
-): ((...args: Parameters<T>) => void) => {
-  let timeout: NodeJS.Timeout | null = null
-  
-  return (...args: Parameters<T>) => {
-    if (timeout) {
-      clearTimeout(timeout)
-    }
-    
-    timeout = setTimeout(() => {
-      func(...args)
-    }, wait)
-  }
-}
-
-export const throttle = <T extends (...args: any[]) => any>(
-  func: T,
-  limit: number
-): ((...args: Parameters<T>) => void) => {
-  let inThrottle: boolean = false
-  
-  return (...args: Parameters<T>) => {
-    if (!inThrottle) {
-      func(...args)
-      inThrottle = true
-      setTimeout(() => inThrottle = false, limit)
-    }
-  }
-}
-
-export const isProduction = (): boolean => {
-  return process.env.NODE_ENV === 'production'
-}
-
-export const isDevelopment = (): boolean => {
-  return process.env.NODE_ENV === 'development' || !process.env.NODE_ENV
-}
-
-export const isTest = (): boolean => {
-  return process.env.NODE_ENV === 'test'
-}
-
-export const deepMerge = <T extends Record<string, any>>(target: T, source: Partial<T>): T => {
-  const result = { ...target }
-  
-  for (const key in source) {
-    if (source.hasOwnProperty(key)) {
-      const sourceValue = source[key]
-      const targetValue = result[key]
-      
-      if (
-        sourceValue &&
-        typeof sourceValue === 'object' &&
-        !Array.isArray(sourceValue) &&
-        targetValue &&
-        typeof targetValue === 'object' &&
-        !Array.isArray(targetValue)
-      ) {
-        result[key] = deepMerge(targetValue, sourceValue)
-      } else {
-        result[key] = sourceValue as T[Extract<keyof T, string>]
-      }
-    }
-  }
-  
-  return result
-}
-
-export const pick = <T extends Record<string, any>, K extends keyof T>(
-  obj: T,
-  keys: K[]
-): Pick<T, K> => {
-  const result = {} as Pick<T, K>
-  
-  for (const key of keys) {
-    if (key in obj) {
-      result[key] = obj[key]
-    }
-  }
-  
-  return result
-}
-
-export const omit = <T extends Record<string, any>, K extends keyof T>(
-  obj: T,
-  keys: K[]
-): Omit<T, K> => {
-  const result = { ...obj }
-  
-  for (const key of keys) {
-    delete result[key]
-  }
-  
-  return result
-}
-
-export const generateId = (length: number = 8): string => {
-  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-  let result = ''
-  
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length))
-  }
-  
-  return result
-}
-
-export const safeJsonParse = <T = any>(json: string, fallback: T): T => {
-  try {
-    return JSON.parse(json)
-  } catch {
-    return fallback
-  }
-}
-
-export const safeJsonStringify = (obj: any, fallback: string = '{}'): string => {
-  try {
-    return JSON.stringify(obj)
-  } catch {
-    return fallback
-  }
-}

package/core/utils/index.ts

@@ -1,18 +0,0 @@
-/**
- * FluxStack Utilities
- * Main exports for utility functions and classes
- */
-
-// Logger utilities
-export { logger, log } from "./logger"
-export type { Logger } from "./logger/index"
-
-// Error handling
-export * from "./errors"
-
-// Monitoring
-export { MetricsCollector } from "./monitoring"
-export type * from "./monitoring"
-
-// General helpers
-export * from "./helpers"