@elevasis/core 0.7.0 → 0.8.0

package/src/platform/resilience/http-error-mapper.ts

@@ -1,129 +1,129 @@
-/**
- * HTTP Error Mapper
- *
- * Shared utility for mapping HTTP status codes to ToolingError types.
- * Used by all integration adapters for consistent error handling.
- *
- * Standard mapping:
- * - 401/403 -> credentials_invalid (authentication failed)
- * - 400/404/409 -> validation_error (non-retryable client errors)
- * - 429 -> rate_limit_exceeded (retryable)
- * - 500+ -> server_unavailable (retryable)
- * - Other 4xx -> validation_error (non-retryable)
- * - Other -> api_error (retryable)
- */
-
-import { ToolingError, type ToolingErrorType } from '../../execution/engine/tools/types'
-
-/**
- * Context for HTTP error creation
- */
-export interface HttpErrorContext {
-  integration: string
-  method: string
-  statusCode?: number
-  organizationId?: string
-  [key: string]: unknown
-}
-
-/**
- * Custom error parser function type
- * Allows adapters to extract error messages from API-specific response formats
- */
-export type ErrorParser = (responseBody: string) => string | undefined
-
-/**
- * Map HTTP status code to ToolingError type
- *
- * Standard mapping used by all integration adapters:
- * - 401/403 -> credentials_invalid (authentication failed)
- * - 400/404/409 -> validation_error (non-retryable client errors)
- * - 429 -> rate_limit_exceeded (retryable)
- * - 500+ -> server_unavailable (retryable)
- * - Other 4xx -> validation_error (non-retryable)
- * - Other -> api_error (retryable)
- *
- * @param status - HTTP status code
- * @returns ToolingErrorType for the status code
- */
-export function mapHttpStatusToErrorType(status: number): ToolingErrorType {
-  if (status === 401 || status === 403) return 'credentials_invalid'
-  if (status === 404 || status === 400 || status === 409) return 'validation_error'
-  if (status === 429) return 'rate_limit_exceeded'
-  if (status >= 500) return 'server_unavailable'
-  if (status >= 400) return 'validation_error'
-  return 'api_error'
-}
-
-/**
- * Create ToolingError from HTTP response
- *
- * Reads response body, parses error message, and creates appropriate ToolingError.
- * Supports custom error parser for API-specific response formats.
- *
- * @param response - Fetch Response object
- * @param context - Error context (integration name, method, etc.)
- * @param parseError - Optional custom parser for API-specific error formats
- * @returns ToolingError with appropriate type and message
- *
- * @example
- * // Basic usage
- * if (!response.ok) {
- *   throw await createHttpError(response, {
- *     integration: 'attio',
- *     method: 'listRecords',
- *     listId
- *   })
- * }
- *
- * @example
- * // With custom error parser
- * if (!response.ok) {
- *   throw await createHttpError(
- *     response,
- *     { integration: 'attio', method: 'createRecord' },
- *     (body) => {
- *       const json = JSON.parse(body)
- *       return json.message
- *     }
- *   )
- * }
- */
-export async function createHttpError(
-  response: Response,
-  context: HttpErrorContext,
-  parseError?: ErrorParser
-): Promise<ToolingError> {
-  const errorText = await response.text()
-  let message = `${context.integration} API error: ${response.status} ${response.statusText}`
-
-  // Try custom parser first, then generic JSON parsing
-  if (parseError) {
-    try {
-      const parsed = parseError(errorText)
-      if (parsed) message = parsed
-    } catch {
-      // Custom parser failed, fall through to generic parsing
-    }
-  }
-
-  // Generic JSON parsing if no custom parser or custom parser didn't return a message
-  if (!parseError || message.includes('API error:')) {
-    try {
-      const json = JSON.parse(errorText)
-      const parsedMessage = json.message || json.error?.message
-      if (parsedMessage) message = parsedMessage
-    } catch {
-      // Response is not JSON, use raw text if available
-      if (errorText && errorText.length < 500) {
-        message = errorText
-      }
-    }
-  }
-
-  return new ToolingError(
-    mapHttpStatusToErrorType(response.status),
-    message,
-    { ...context, statusCode: response.status }
-  )
-}
+/**
+ * HTTP Error Mapper
+ *
+ * Shared utility for mapping HTTP status codes to ToolingError types.
+ * Used by all integration adapters for consistent error handling.
+ *
+ * Standard mapping:
+ * - 401/403 -> credentials_invalid (authentication failed)
+ * - 400/404/409 -> validation_error (non-retryable client errors)
+ * - 429 -> rate_limit_exceeded (retryable)
+ * - 500+ -> server_unavailable (retryable)
+ * - Other 4xx -> validation_error (non-retryable)
+ * - Other -> api_error (retryable)
+ */
+
+import { ToolingError, type ToolingErrorType } from '../../execution/engine/tools/types'
+
+/**
+ * Context for HTTP error creation
+ */
+export interface HttpErrorContext {
+  integration: string
+  method: string
+  statusCode?: number
+  organizationId?: string
+  [key: string]: unknown
+}
+
+/**
+ * Custom error parser function type
+ * Allows adapters to extract error messages from API-specific response formats
+ */
+export type ErrorParser = (responseBody: string) => string | undefined
+
+/**
+ * Map HTTP status code to ToolingError type
+ *
+ * Standard mapping used by all integration adapters:
+ * - 401/403 -> credentials_invalid (authentication failed)
+ * - 400/404/409 -> validation_error (non-retryable client errors)
+ * - 429 -> rate_limit_exceeded (retryable)
+ * - 500+ -> server_unavailable (retryable)
+ * - Other 4xx -> validation_error (non-retryable)
+ * - Other -> api_error (retryable)
+ *
+ * @param status - HTTP status code
+ * @returns ToolingErrorType for the status code
+ */
+export function mapHttpStatusToErrorType(status: number): ToolingErrorType {
+  if (status === 401 || status === 403) return 'credentials_invalid'
+  if (status === 404 || status === 400 || status === 409) return 'validation_error'
+  if (status === 429) return 'rate_limit_exceeded'
+  if (status >= 500) return 'server_unavailable'
+  if (status >= 400) return 'validation_error'
+  return 'api_error'
+}
+
+/**
+ * Create ToolingError from HTTP response
+ *
+ * Reads response body, parses error message, and creates appropriate ToolingError.
+ * Supports custom error parser for API-specific response formats.
+ *
+ * @param response - Fetch Response object
+ * @param context - Error context (integration name, method, etc.)
+ * @param parseError - Optional custom parser for API-specific error formats
+ * @returns ToolingError with appropriate type and message
+ *
+ * @example
+ * // Basic usage
+ * if (!response.ok) {
+ *   throw await createHttpError(response, {
+ *     integration: 'attio',
+ *     method: 'listRecords',
+ *     listId
+ *   })
+ * }
+ *
+ * @example
+ * // With custom error parser
+ * if (!response.ok) {
+ *   throw await createHttpError(
+ *     response,
+ *     { integration: 'attio', method: 'createRecord' },
+ *     (body) => {
+ *       const json = JSON.parse(body)
+ *       return json.message
+ *     }
+ *   )
+ * }
+ */
+export async function createHttpError(
+  response: Response,
+  context: HttpErrorContext,
+  parseError?: ErrorParser
+): Promise<ToolingError> {
+  const errorText = await response.text()
+  let message = `${context.integration} API error: ${response.status} ${response.statusText}`
+
+  // Try custom parser first, then generic JSON parsing
+  if (parseError) {
+    try {
+      const parsed = parseError(errorText)
+      if (parsed) message = parsed
+    } catch {
+      // Custom parser failed, fall through to generic parsing
+    }
+  }
+
+  // Generic JSON parsing if no custom parser or custom parser didn't return a message
+  if (!parseError || message.includes('API error:')) {
+    try {
+      const json = JSON.parse(errorText)
+      const parsedMessage = json.message || json.error?.message
+      if (parsedMessage) message = parsedMessage
+    } catch {
+      // Response is not JSON, use raw text if available
+      if (errorText && errorText.length < 500) {
+        message = errorText
+      }
+    }
+  }
+
+  return new ToolingError(
+    mapHttpStatusToErrorType(response.status),
+    message,
+    { ...context, statusCode: response.status }
+  )
+}

package/src/platform/resilience/index.ts

@@ -1,93 +1,93 @@
-/**
- * Resilience utilities for protecting against external service failures.
- *
- * This module provides:
- * - Timeout wrappers for external service calls
- * - Circuit breaker pattern for preventing cascading failures
- * - Infrastructure error types for proper error classification
- * - Rate limiting (token bucket algorithm)
- * - Retry with exponential backoff
- * - HTTP error mapping
- *
- * @example
- * ```typescript
- * import {
- *   withTimeout,
- *   SERVICE_TIMEOUTS,
- *   createCircuitBreaker,
- *   ServiceTimeoutError,
- *   ServiceUnavailableError,
- *   isInfrastructureError,
- *   withRetry,
- *   DEFAULT_RETRY_POLICY,
- *   createRateLimiter,
- *   createHttpError
- * } from '@repo/core/resilience'
- *
- * // Wrap external calls with timeout
- * const result = await withTimeout(
- *   externalService.call(),
- *   SERVICE_TIMEOUTS.WORKOS_JWT,
- *   'ServiceName',
- *   'operation'
- * )
- *
- * // Use circuit breaker for services with repeated failures
- * const breaker = createCircuitBreaker('my-service')
- * const data = await breaker.execute(() => myService.fetch())
- *
- * // Use retry with exponential backoff
- * const response = await withRetry(
- *   () => fetch('/api/data'),
- *   DEFAULT_RETRY_POLICY
- * )
- * ```
- */
-
-// Error types
-export {
-  ServiceTimeoutError,
-  ServiceUnavailableError,
-  isInfrastructureError
-} from './errors'
-
-// Timeout utility
-export { withTimeout, SERVICE_TIMEOUTS } from './timeout'
-
-// Circuit breaker
-export {
-  createCircuitBreaker,
-  CircuitState,
-  type CircuitBreaker,
-  type CircuitBreakerConfig
-} from './circuit-breaker'
-
-// Rate limiting
-export {
-  InMemoryRateLimiter,
-  createRateLimiter
-} from './rate-limiter'
-
-// Retry logic
-export {
-  withRetry,
-  calculateRetryDelay,
-  sleep
-} from './retry'
-
-// Rate limiter types
-export {
-  type RateLimiter,
-  type RetryPolicy
-} from './rate-limiter-types'
-
-// Retry policy constant (canonical source: constants/resilience)
-export { DEFAULT_RETRY_POLICY } from '../constants/resilience'
-
-// HTTP error mapping
-export {
-  createHttpError,
-  mapHttpStatusToErrorType,
-  type HttpErrorContext,
-  type ErrorParser
-} from './http-error-mapper'
+/**
+ * Resilience utilities for protecting against external service failures.
+ *
+ * This module provides:
+ * - Timeout wrappers for external service calls
+ * - Circuit breaker pattern for preventing cascading failures
+ * - Infrastructure error types for proper error classification
+ * - Rate limiting (token bucket algorithm)
+ * - Retry with exponential backoff
+ * - HTTP error mapping
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   withTimeout,
+ *   SERVICE_TIMEOUTS,
+ *   createCircuitBreaker,
+ *   ServiceTimeoutError,
+ *   ServiceUnavailableError,
+ *   isInfrastructureError,
+ *   withRetry,
+ *   DEFAULT_RETRY_POLICY,
+ *   createRateLimiter,
+ *   createHttpError
+ * } from '@repo/core/resilience'
+ *
+ * // Wrap external calls with timeout
+ * const result = await withTimeout(
+ *   externalService.call(),
+ *   SERVICE_TIMEOUTS.WORKOS_JWT,
+ *   'ServiceName',
+ *   'operation'
+ * )
+ *
+ * // Use circuit breaker for services with repeated failures
+ * const breaker = createCircuitBreaker('my-service')
+ * const data = await breaker.execute(() => myService.fetch())
+ *
+ * // Use retry with exponential backoff
+ * const response = await withRetry(
+ *   () => fetch('/api/data'),
+ *   DEFAULT_RETRY_POLICY
+ * )
+ * ```
+ */
+
+// Error types
+export {
+  ServiceTimeoutError,
+  ServiceUnavailableError,
+  isInfrastructureError
+} from './errors'
+
+// Timeout utility
+export { withTimeout, SERVICE_TIMEOUTS } from './timeout'
+
+// Circuit breaker
+export {
+  createCircuitBreaker,
+  CircuitState,
+  type CircuitBreaker,
+  type CircuitBreakerConfig
+} from './circuit-breaker'
+
+// Rate limiting
+export {
+  InMemoryRateLimiter,
+  createRateLimiter
+} from './rate-limiter'
+
+// Retry logic
+export {
+  withRetry,
+  calculateRetryDelay,
+  sleep
+} from './retry'
+
+// Rate limiter types
+export {
+  type RateLimiter,
+  type RetryPolicy
+} from './rate-limiter-types'
+
+// Retry policy constant (canonical source: constants/resilience)
+export { DEFAULT_RETRY_POLICY } from '../constants/resilience'
+
+// HTTP error mapping
+export {
+  createHttpError,
+  mapHttpStatusToErrorType,
+  type HttpErrorContext,
+  type ErrorParser
+} from './http-error-mapper'

package/src/platform/resilience/rate-limiter-types.ts

@@ -1,46 +1,46 @@
-/**
- * Shared utility types for integration tools
- *
- * These types define the interfaces for rate limiting and retry logic
- * that are used by integration tools.
- */
-
-/**
- * Rate limiter interface
- * Implements token bucket algorithm for rate limiting
- */
-export interface RateLimiter {
-  /**
-   * Check if request is allowed
-   * @param key - Rate limit key (e.g., '${organizationId}:${integration}')
-   * @returns true if allowed, false if rate limited
-   */
-  allow(key: string): Promise<boolean>
-
-  /**
-   * Get remaining tokens for key
-   * @param key - Rate limit key
-   * @returns Number of tokens remaining
-   */
-  remaining(key: string): Promise<number>
-
-  /**
-   * Reset rate limit for key
-   * @param key - Rate limit key
-   */
-  reset(key: string): Promise<void>
-}
-
-/**
- * Retry policy configuration
- */
-export interface RetryPolicy {
-  /** Maximum number of retry attempts */
-  maxRetries: number
-  /** Initial delay in ms (exponential backoff) */
-  initialDelayMs: number
-  /** Maximum delay in ms (cap for exponential backoff) */
-  maxDelayMs: number
-  /** Jitter factor (0-1, adds randomness to prevent thundering herd) */
-  jitterFactor: number
-}
+/**
+ * Shared utility types for integration tools
+ *
+ * These types define the interfaces for rate limiting and retry logic
+ * that are used by integration tools.
+ */
+
+/**
+ * Rate limiter interface
+ * Implements token bucket algorithm for rate limiting
+ */
+export interface RateLimiter {
+  /**
+   * Check if request is allowed
+   * @param key - Rate limit key (e.g., '${organizationId}:${integration}')
+   * @returns true if allowed, false if rate limited
+   */
+  allow(key: string): Promise<boolean>
+
+  /**
+   * Get remaining tokens for key
+   * @param key - Rate limit key
+   * @returns Number of tokens remaining
+   */
+  remaining(key: string): Promise<number>
+
+  /**
+   * Reset rate limit for key
+   * @param key - Rate limit key
+   */
+  reset(key: string): Promise<void>
+}
+
+/**
+ * Retry policy configuration
+ */
+export interface RetryPolicy {
+  /** Maximum number of retry attempts */
+  maxRetries: number
+  /** Initial delay in ms (exponential backoff) */
+  initialDelayMs: number
+  /** Maximum delay in ms (cap for exponential backoff) */
+  maxDelayMs: number
+  /** Jitter factor (0-1, adds randomness to prevent thundering herd) */
+  jitterFactor: number
+}