create-fluxstack 1.0.2 → 1.0.4

package/meu-app-teste/core/utils/env-runtime.ts

@@ -0,0 +1,252 @@
+/**
+ * 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/meu-app-teste/core/utils/errors/codes.ts

@@ -0,0 +1,115 @@
+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/meu-app-teste/core/utils/errors/handlers.ts

@@ -0,0 +1,63 @@
+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/meu-app-teste/core/utils/errors/index.ts

@@ -0,0 +1,81 @@
+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/meu-app-teste/core/utils/helpers.ts

@@ -0,0 +1,180 @@
+/**
+ * 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/meu-app-teste/core/utils/index.ts

@@ -0,0 +1,18 @@
+/**
+ * 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"