create-fluxstack 1.16.0 → 1.17.0

package/core/utils/env.ts

@@ -27,7 +27,7 @@
  * Uses Bun.env (runtime) → process.env (fallback) → eval (last resort)
  */
 class EnvLoader {
-  private cache = new Map<string, any>()
+  private cache = new Map<string, unknown>()
   private accessor: () => Record<string, string | undefined>
 
   constructor() {
@@ -38,17 +38,19 @@ class EnvLoader {
    * Create dynamic accessor to prevent build-time inlining
    */
   private createAccessor(): () => Record<string, string | undefined> {
-    const global = globalThis as any
+    const global = globalThis as unknown as Record<string, Record<string, unknown> | undefined>
 
     return () => {
       // Try Bun.env first (most reliable in Bun)
-      if (global['Bun']?.['env']) {
-        return global['Bun']['env']
+      const bun = global['Bun'] as Record<string, unknown> | undefined
+      if (bun?.['env']) {
+        return bun['env'] as Record<string, string | undefined>
       }
 
       // Fallback to process.env
-      if (global['process']?.['env']) {
-        return global['process']['env']
+      const proc = global['process'] as Record<string, unknown> | undefined
+      if (proc?.['env']) {
+        return proc['env'] as Record<string, string | undefined>
       }
 
       return {}
@@ -63,7 +65,7 @@ class EnvLoader {
     // Check cache first
     const cacheKey = `${key}:${typeof defaultValue}`
     if (this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey)
+      return this.cache.get(cacheKey) as T
     }
 
     const env = this.accessor()
@@ -75,7 +77,7 @@ class EnvLoader {
     }
 
     // Auto-detect type from defaultValue
-    let result: any = value
+    let result: unknown = value
 
     if (typeof defaultValue === 'number') {
       const parsed = Number(value)

package/core/utils/errors/codes.ts

@@ -1,115 +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'
+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

@@ -21,7 +21,7 @@ export interface ErrorMetricsCollector {
 
 export interface ErrorRecoveryStrategy {
   canRecover(error: FluxStackError): boolean
-  recover(error: FluxStackError, context: ErrorHandlerContext): Promise<any> | any
+  recover(error: FluxStackError, context: ErrorHandlerContext): Promise<ErrorSerializedResponse> | ErrorSerializedResponse
 }
 
 export interface ErrorHandlerOptions {
@@ -144,7 +144,7 @@ export class EnhancedErrorHandler {
   /**
    * Format stack trace to readable string (handles Bun CallSite objects)
    */
-  private formatErrorStack(stack: any): string | undefined {
+  private formatErrorStack(stack: unknown): string | undefined {
     if (!stack) return undefined
 
     // If stack is already a string, return it
@@ -153,7 +153,7 @@ export class EnhancedErrorHandler {
     // If stack is an array of CallSite objects (Bun), format them
     if (Array.isArray(stack)) {
       return stack
-        .map((site: any, index: number) => {
+        .map((site: { getFileName?: () => string; getLineNumber?: () => number; getColumnNumber?: () => number; getFunctionName?: () => string }, index: number) => {
           try {
             const fileName = site.getFileName?.() || 'unknown'
             const lineNumber = site.getLineNumber?.() || 0
@@ -193,10 +193,10 @@ export class EnhancedErrorHandler {
     }
 
     // Skip logging for Vite internal routes (even if NOT_FOUND logging is enabled)
-    if (error.code === 'NOT_FOUND' && error.metadata?.path) {
+    if (error.code === 'NOT_FOUND' && typeof error.metadata?.path === 'string') {
       const path = error.metadata.path
-      if (path.startsWith('/@') || 
-          path.startsWith('/__vite') || 
+      if (path.startsWith('/@') ||
+          path.startsWith('/__vite') ||
           path.includes('/.vite/') ||
           path.endsWith('.js.map') ||
           path.endsWith('.css.map')) {
@@ -228,18 +228,20 @@ export class EnhancedErrorHandler {
     return response
   }
 
-  private sanitizeErrorResponse(errorResponse: any): any {
+  private sanitizeErrorResponse(errorResponse: ErrorSerializedResponse['error']): ErrorSerializedResponse['error'] {
     const sanitized = { ...errorResponse }
-    
+
     // Remove potentially sensitive fields in production
-    if (sanitized.details) {
+    if (sanitized.details && typeof sanitized.details === 'object' && sanitized.details !== null) {
       // Remove sensitive fields from details
+      const details = sanitized.details as Record<string, unknown>
       const sensitiveFields = ['password', 'token', 'secret', 'key', 'credential']
       for (const field of sensitiveFields) {
-        if (sanitized.details[field]) {
-          sanitized.details[field] = '[REDACTED]'
+        if (details[field]) {
+          details[field] = '[REDACTED]'
         }
       }
+      sanitized.details = details
     }
 
     return sanitized
@@ -249,7 +251,7 @@ export class EnhancedErrorHandler {
     this.recoveryStrategies.push(strategy)
   }
 
-  removeRecoveryStrategy(strategyClass: new (...args: any[]) => ErrorRecoveryStrategy): void {
+  removeRecoveryStrategy(strategyClass: new (...args: unknown[]) => ErrorRecoveryStrategy): void {
     this.recoveryStrategies = this.recoveryStrategies.filter(
       strategy => !(strategy instanceof strategyClass)
     )
@@ -289,12 +291,14 @@ export class RetryRecoveryStrategy implements ErrorRecoveryStrategy {
   ) {}
 
   canRecover(error: FluxStackError): boolean {
-    return this.retryableCodes.includes(error.code) && 
-           (!error.context?.retryCount || error.context.retryCount < this.maxRetries)
+    const ctx = error.context as Record<string, unknown> | undefined
+    return this.retryableCodes.includes(error.code) &&
+           (!ctx?.retryCount || (ctx.retryCount as number) < this.maxRetries)
   }
 
-  async recover(error: FluxStackError, context: ErrorHandlerContext): Promise<any> {
-    const retryCount = (error.context?.retryCount || 0) + 1
+  async recover(error: FluxStackError, context: ErrorHandlerContext): Promise<ErrorSerializedResponse> {
+    const ctx = error.context as Record<string, unknown> | undefined
+    const retryCount = ((ctx?.retryCount as number) || 0) + 1
     
     context.logger.info('Attempting error recovery', {
       errorCode: error.code,
@@ -313,7 +317,7 @@ export class RetryRecoveryStrategy implements ErrorRecoveryStrategy {
 
 export class FallbackRecoveryStrategy implements ErrorRecoveryStrategy {
   constructor(
-    private fallbackResponse: any,
+    private fallbackResponse: unknown,
     private applicableCodes: string[] = ['EXTERNAL_SERVICE_ERROR']
   ) {}
 
@@ -321,15 +325,21 @@ export class FallbackRecoveryStrategy implements ErrorRecoveryStrategy {
     return this.applicableCodes.includes(error.code)
   }
 
-  recover(error: FluxStackError, context: ErrorHandlerContext): any {
+  recover(error: FluxStackError, context: ErrorHandlerContext): ErrorSerializedResponse {
     context.logger.info('Using fallback recovery', {
       errorCode: error.code,
       correlationId: error.metadata.correlationId
     })
 
     return {
-      data: this.fallbackResponse,
-      warning: 'Fallback data provided due to service unavailability'
+      error: {
+        message: 'Fallback data provided due to service unavailability',
+        code: error.code,
+        statusCode: error.statusCode,
+        details: { fallback: this.fallbackResponse },
+        timestamp: new Date().toISOString(),
+        correlationId: error.metadata.correlationId as string | undefined
+      }
     }
   }
 }