create-fluxstack 1.10.1 → 1.12.0

package/core/utils/env.ts

@@ -9,7 +9,7 @@
  *
  * @example
  * ```ts
- * import { env } from '@/core/utils/env'
+ * import { env } from '@core/utils/env'
  *
  * const port = env.PORT                    // number (3000)
  * const debug = env.DEBUG                  // boolean (false)
@@ -51,13 +51,7 @@ class EnvLoader {
         return global['process']['env']
       }
 
-      // Last resort: eval to bypass static analysis
-      try {
-        const proc = eval('typeof process !== "undefined" ? process : null')
-        return proc?.env || {}
-      } catch {
-        return {}
-      }
+      return {}
     }
   }
 

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

@@ -120,13 +120,17 @@ export class EnhancedErrorHandler {
 
   private logError(error: FluxStackError, logger: Logger, isDevelopment: boolean): void {
     const logLevel = this.getLogLevel(error)
+
+    // Format stack trace properly (handles CallSite objects from Bun)
+    const formattedStack = isDevelopment ? this.formatErrorStack(error.stack) : undefined
+
     const logData = {
       code: error.code,
       statusCode: error.statusCode,
       context: error.context,
       metadata: error.metadata,
       isOperational: error.isOperational,
-      ...(isDevelopment && { stack: error.stack })
+      ...(formattedStack && { stack: formattedStack })
     }
 
     // Skip logging for certain errors to reduce noise
@@ -137,6 +141,37 @@ export class EnhancedErrorHandler {
     logger[logLevel](error.message, logData)
   }
 
+  /**
+   * Format stack trace to readable string (handles Bun CallSite objects)
+   */
+  private formatErrorStack(stack: any): string | undefined {
+    if (!stack) return undefined
+
+    // If stack is already a string, return it
+    if (typeof stack === 'string') return stack
+
+    // If stack is an array of CallSite objects (Bun), format them
+    if (Array.isArray(stack)) {
+      return stack
+        .map((site: any, index: number) => {
+          try {
+            const fileName = site.getFileName?.() || 'unknown'
+            const lineNumber = site.getLineNumber?.() || 0
+            const columnNumber = site.getColumnNumber?.() || 0
+            const functionName = site.getFunctionName?.() || 'anonymous'
+
+            return `    at ${functionName} (${fileName}:${lineNumber}:${columnNumber})`
+          } catch {
+            return `    at ${String(site)}`
+          }
+        })
+        .join('\n')
+    }
+
+    // Fallback: convert to string
+    return String(stack)
+  }
+
   private getLogLevel(error: FluxStackError): 'error' | 'warn' | 'info' {
     if (!error.isOperational) {
       return 'error'

package/core/utils/errors/index.ts

@@ -46,13 +46,45 @@ export class FluxStackError extends Error {
     this.metadata = metadata
     this.isOperational = isOperational
     this.userMessage = userMessage
-    
+
     // Maintain proper stack trace
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, FluxStackError)
     }
   }
 
+  /**
+   * Format stack trace to string (handles both string and CallSite array)
+   */
+  private formatStack(): string | undefined {
+    if (!this.stack) return undefined
+
+    // If stack is already a string, return it
+    if (typeof this.stack === 'string') return this.stack
+
+    // If stack is an array of CallSite objects (Bun), format them
+    const stackValue = this.stack as unknown
+    if (Array.isArray(stackValue)) {
+      return stackValue
+        .map((site: any) => {
+          try {
+            const fileName = site.getFileName?.() || 'unknown'
+            const lineNumber = site.getLineNumber?.() || 0
+            const columnNumber = site.getColumnNumber?.() || 0
+            const functionName = site.getFunctionName?.() || 'anonymous'
+
+            return `    at ${functionName} (${fileName}:${lineNumber}:${columnNumber})`
+          } catch {
+            return `    at ${String(site)}`
+          }
+        })
+        .join('\n')
+    }
+
+    // Fallback: convert to string
+    return String(this.stack)
+  }
+
   toJSON() {
     return {
       name: this.name,
@@ -64,7 +96,7 @@ export class FluxStackError extends Error {
       metadata: this.metadata,
       isOperational: this.isOperational,
       userMessage: this.userMessage,
-      stack: this.stack
+      stack: this.formatStack()
     }
   }
 
@@ -77,7 +109,7 @@ export class FluxStackError extends Error {
         ...(this.context && { details: this.context }),
         timestamp: this.timestamp.toISOString(),
         ...(this.metadata.correlationId && { correlationId: this.metadata.correlationId }),
-        ...(isDevelopment && { stack: this.stack })
+        ...(isDevelopment && { stack: this.formatStack() })
       }
     }
   }
@@ -583,9 +615,21 @@ export const wrapError = (error: Error, metadata?: ErrorMetadata): FluxStackErro
   if (isFluxStackError(error)) {
     return metadata ? error.withMetadata(metadata) : error
   }
-  
+
+  // Detect Elysia validation errors (thrown by TypeBox schema validation)
+  const errorAny = error as any
+  if (
+    error.constructor?.name === 'ValidationError' ||
+    error.constructor?.name === 'TransformDecodeError' ||
+    (typeof errorAny.status === 'number' && errorAny.status >= 400 && errorAny.status < 500)
+  ) {
+    const status = errorAny.status ?? 422
+    const message = error.message || 'Validation failed'
+    return new ValidationError(message, { originalError: error.name, status }, metadata)
+  }
+
   return new InternalServerError(error.message, { originalError: error.name }, metadata)
 }
 
 // Re-export error codes for convenience
-export { ERROR_CODES, type ErrorCode, getErrorMessage } from './codes'
+export { ERROR_CODES, type ErrorCode, getErrorMessage } from './codes'

package/core/utils/errors/middleware.ts

@@ -1,114 +1,114 @@
-import { Elysia } from 'elysia'
-import { EnhancedErrorHandler, type ErrorHandlerContext, type ErrorHandlerOptions, type ErrorMetricsCollector } from './handlers'
-import type { Logger } from '../logger/index'
-
-export interface ErrorMiddlewareOptions extends ErrorHandlerOptions {
-  logger?: Logger
-  isDevelopment?: boolean
-  enableRequestContext?: boolean
-  metricsCollector?: ErrorMetricsCollector
-}
-
-export const errorMiddleware = (options: ErrorMiddlewareOptions = {}) => {
-  const handler = new EnhancedErrorHandler(options)
-  
-  return new Elysia({ name: 'error-handler' })
-    .onError(async ({ error, request, path, set }) => {
-      // Extract request context
-      const context: ErrorHandlerContext = {
-        logger: options.logger || console as any, // Fallback to console if no logger provided
-        isDevelopment: options.isDevelopment ?? process.env.NODE_ENV === 'development',
-        request,
-        path,
-        method: request.method,
-        correlationId: request.headers.get('x-correlation-id') || undefined,
-        userId: request.headers.get('x-user-id') || undefined,
-        userAgent: request.headers.get('user-agent') || undefined,
-        ip: request.headers.get('x-forwarded-for') || 
-            request.headers.get('x-real-ip') || 
-            'unknown',
-        metricsCollector: options.metricsCollector
-      }
-
-      try {
-        // Convert Elysia error to standard Error if needed
-        const standardError = error instanceof Error ? error : new Error(String(error))
-        const errorResponse = await handler.handle(standardError, context)
-        
-        // Set response status code
-        set.status = errorResponse.error.statusCode
-        
-        // Set correlation ID header if available
-        if (errorResponse.error.correlationId) {
-          set.headers['x-correlation-id'] = errorResponse.error.correlationId
-        }
-        
-        return errorResponse
-      } catch (handlerError) {
-        // Fallback error handling if the error handler itself fails
-        const fallbackLogger = options.logger || console as any
-        fallbackLogger.error('Error handler failed', {
-          originalError: error instanceof Error ? error.message : String(error),
-          handlerError: handlerError instanceof Error ? handlerError.message : handlerError
-        })
-        
-        set.status = 500
-        return {
-          error: {
-            message: 'Internal server error',
-            code: 'INTERNAL_ERROR',
-            statusCode: 500,
-            timestamp: new Date().toISOString()
-          }
-        }
-      }
-    })
-}
-
-// Correlation ID middleware to add correlation IDs to requests
-export const correlationIdMiddleware = () => {
-  return new Elysia({ name: 'correlation-id' })
-    .onRequest(({ request, set }) => {
-      // Check if correlation ID already exists in headers
-      let correlationId = request.headers.get('x-correlation-id')
-      
-      // Generate new correlation ID if not present
-      if (!correlationId) {
-        correlationId = crypto.randomUUID()
-      }
-      
-      // Add correlation ID to response headers
-      set.headers['x-correlation-id'] = correlationId
-      
-      // Store correlation ID in request context for later use
-      // Note: This would typically be stored in a request-scoped context
-      // For now, we'll rely on the error handler to extract it from headers
-    })
-}
-
-// Request context middleware to extract and store request information
-export const requestContextMiddleware = () => {
-  return new Elysia({ name: 'request-context' })
-    .onRequest(({ request, set }) => {
-      // Extract useful request information and store in headers for error handling
-      const userAgent = request.headers.get('user-agent')
-      const ip = request.headers.get('x-forwarded-for') || 
-                 request.headers.get('x-real-ip') || 
-                 'unknown'
-      
-      // Store in custom headers for error handler access
-      // In a real implementation, this would use request-scoped storage
-      if (userAgent) {
-        set.headers['x-internal-user-agent'] = userAgent
-      }
-      set.headers['x-internal-ip'] = ip
-    })
-}
-
-// Combined error handling middleware with all features
-export const fullErrorHandlingMiddleware = (options: ErrorMiddlewareOptions = {}) => {
-  return new Elysia({ name: 'full-error-handling' })
-    .use(correlationIdMiddleware())
-    .use(requestContextMiddleware())
-    .use(errorMiddleware(options))
+import { Elysia } from 'elysia'
+import { EnhancedErrorHandler, type ErrorHandlerContext, type ErrorHandlerOptions, type ErrorMetricsCollector } from './handlers'
+import type { Logger } from '../logger/index'
+
+export interface ErrorMiddlewareOptions extends ErrorHandlerOptions {
+  logger?: Logger
+  isDevelopment?: boolean
+  enableRequestContext?: boolean
+  metricsCollector?: ErrorMetricsCollector
+}
+
+export const errorMiddleware = (options: ErrorMiddlewareOptions = {}) => {
+  const handler = new EnhancedErrorHandler(options)
+  
+  return new Elysia({ name: 'error-handler' })
+    .onError(async ({ error, request, path, set }) => {
+      // Extract request context
+      const context: ErrorHandlerContext = {
+        logger: options.logger || console as any, // Fallback to console if no logger provided
+        isDevelopment: options.isDevelopment ?? process.env.NODE_ENV === 'development',
+        request,
+        path,
+        method: request.method,
+        correlationId: request.headers.get('x-correlation-id') || undefined,
+        userId: request.headers.get('x-user-id') || undefined,
+        userAgent: request.headers.get('user-agent') || undefined,
+        ip: request.headers.get('x-forwarded-for') || 
+            request.headers.get('x-real-ip') || 
+            'unknown',
+        metricsCollector: options.metricsCollector
+      }
+
+      try {
+        // Convert Elysia error to standard Error if needed
+        const standardError = error instanceof Error ? error : new Error(String(error))
+        const errorResponse = await handler.handle(standardError, context)
+        
+        // Set response status code
+        set.status = errorResponse.error.statusCode
+        
+        // Set correlation ID header if available
+        if (errorResponse.error.correlationId) {
+          set.headers['x-correlation-id'] = errorResponse.error.correlationId
+        }
+        
+        return errorResponse
+      } catch (handlerError) {
+        // Fallback error handling if the error handler itself fails
+        const fallbackLogger = options.logger || console as any
+        fallbackLogger.error('Error handler failed', {
+          originalError: error instanceof Error ? error.message : String(error),
+          handlerError: handlerError instanceof Error ? handlerError.message : handlerError
+        })
+        
+        set.status = 500
+        return {
+          error: {
+            message: 'Internal server error',
+            code: 'INTERNAL_ERROR',
+            statusCode: 500,
+            timestamp: new Date().toISOString()
+          }
+        }
+      }
+    })
+}
+
+// Correlation ID middleware to add correlation IDs to requests
+export const correlationIdMiddleware = () => {
+  return new Elysia({ name: 'correlation-id' })
+    .onRequest(({ request, set }) => {
+      // Check if correlation ID already exists in headers
+      let correlationId = request.headers.get('x-correlation-id')
+      
+      // Generate new correlation ID if not present
+      if (!correlationId) {
+        correlationId = crypto.randomUUID()
+      }
+      
+      // Add correlation ID to response headers
+      set.headers['x-correlation-id'] = correlationId
+      
+      // Store correlation ID in request context for later use
+      // Note: This would typically be stored in a request-scoped context
+      // For now, we'll rely on the error handler to extract it from headers
+    })
+}
+
+// Request context middleware to extract and store request information
+export const requestContextMiddleware = () => {
+  return new Elysia({ name: 'request-context' })
+    .onRequest(({ request, set }) => {
+      // Extract useful request information and store in headers for error handling
+      const userAgent = request.headers.get('user-agent')
+      const ip = request.headers.get('x-forwarded-for') || 
+                 request.headers.get('x-real-ip') || 
+                 'unknown'
+      
+      // Store in custom headers for error handler access
+      // In a real implementation, this would use request-scoped storage
+      if (userAgent) {
+        set.headers['x-internal-user-agent'] = userAgent
+      }
+      set.headers['x-internal-ip'] = ip
+    })
+}
+
+// Combined error handling middleware with all features
+export const fullErrorHandlingMiddleware = (options: ErrorMiddlewareOptions = {}) => {
+  return new Elysia({ name: 'full-error-handling' })
+    .use(correlationIdMiddleware())
+    .use(requestContextMiddleware())
+    .use(errorMiddleware(options))
 }

package/core/utils/helpers.ts

@@ -91,23 +91,13 @@ export const throttle = <T extends (...args: any[]) => any>(
  * Uses declarative config system instead of legacy env
  */
 
-export const isProduction = (): boolean => {
-  // Lazy import to avoid circular dependency during module initialization
-  const { appConfig } = require('@/config/app.config')
-  return appConfig.env === 'production'
-}
+const getNodeEnv = (): string => process.env.NODE_ENV || 'development'
 
-export const isDevelopment = (): boolean => {
-  // Lazy import to avoid circular dependency during module initialization
-  const { appConfig } = require('@/config/app.config')
-  return appConfig.env === 'development'
-}
+export const isProduction = (): boolean => getNodeEnv() === 'production'
 
-export const isTest = (): boolean => {
-  // Lazy import to avoid circular dependency during module initialization
-  const { appConfig } = require('@/config/app.config')
-  return appConfig.env === 'test'
-}
+export const isDevelopment = (): boolean => getNodeEnv() === 'development'
+
+export const isTest = (): boolean => getNodeEnv() === 'test'
 
 export const deepMerge = <T extends Record<string, any>>(target: T, source: Partial<T>): T => {
   const result = { ...target }
@@ -188,4 +178,4 @@ export const safeJsonStringify = (obj: any, fallback: string = '{}'): string =>
   } catch {
     return fallback
   }
-}
+}