@elevasis/core 0.7.1 → 0.8.2

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

@@ -1,140 +1,140 @@
-import type { RateLimiter } from './rate-limiter-types'
-import { DEFAULT_RATE_LIMIT_CAPACITY, DEFAULT_RATE_LIMIT_WINDOW_MS, STALE_BUCKET_MULTIPLIER } from '../constants/resilience'
-
-/**
- * Token bucket state
- */
-interface TokenBucket {
-  tokens: number
-  lastRefill: number
-}
-
-/**
- * In-memory token bucket rate limiter
- *
- * Implements token bucket algorithm for rate limiting integration API calls.
- * Default: 60 requests per minute per organization per integration.
- *
- * Pattern: Stateful class (justified - manages rate limit state)
- *
- * @example
- * const limiter = new InMemoryRateLimiter(60, 60000) // 60 req/min
- * const allowed = await limiter.allow('org123:gmail')
- * if (!allowed) {
- *   throw new ToolingError('rate_limit_exceeded', 'Rate limit exceeded')
- * }
- */
-export class InMemoryRateLimiter implements RateLimiter {
-  private buckets = new Map<string, TokenBucket>()
-  private lastEviction = Date.now()
-
-  /**
-   * @param capacity - Maximum tokens (requests) allowed
-   * @param refillIntervalMs - Refill interval in milliseconds
-   */
-  constructor(
-    private readonly capacity: number = DEFAULT_RATE_LIMIT_CAPACITY,
-    private readonly refillIntervalMs: number = DEFAULT_RATE_LIMIT_WINDOW_MS
-  ) {}
-
-  /**
-   * Check if request is allowed and consume token if available
-   */
-  async allow(key: string): Promise<boolean> {
-    const bucket = this.getOrCreateBucket(key)
-    this.refillBucket(bucket)
-
-    if (bucket.tokens > 0) {
-      bucket.tokens -= 1
-      return true
-    }
-
-    return false
-  }
-
-  /**
-   * Get remaining tokens for key
-   */
-  async remaining(key: string): Promise<number> {
-    const bucket = this.getOrCreateBucket(key)
-    this.refillBucket(bucket)
-    return Math.floor(bucket.tokens)
-  }
-
-  /**
-   * Reset rate limit for key (removes bucket)
-   */
-  async reset(key: string): Promise<void> {
-    this.buckets.delete(key)
-  }
-
-  /**
-   * Get or create token bucket for key
-   * Lazily evicts stale buckets to prevent memory leaks
-   */
-  private getOrCreateBucket(key: string): TokenBucket {
-    this.evictStaleBuckets()
-
-    let bucket = this.buckets.get(key)
-    if (!bucket) {
-      bucket = {
-        tokens: this.capacity,
-        lastRefill: Date.now()
-      }
-      this.buckets.set(key, bucket)
-    }
-    return bucket
-  }
-
-  /**
-   * Evict buckets that haven't been accessed in 5x the refill interval
-   * Runs at most once per refill interval to avoid overhead
-   */
-  private evictStaleBuckets(): void {
-    const now = Date.now()
-    if (now - this.lastEviction < this.refillIntervalMs) return
-    this.lastEviction = now
-
-    const staleThreshold = this.refillIntervalMs * STALE_BUCKET_MULTIPLIER
-    for (const [key, bucket] of this.buckets) {
-      if (now - bucket.lastRefill > staleThreshold) {
-        this.buckets.delete(key)
-      }
-    }
-  }
-
-  /**
-   * Refill bucket based on time elapsed
-   * Uses linear refill: tokens added = (elapsed / interval) * capacity
-   */
-  private refillBucket(bucket: TokenBucket): void {
-    const now = Date.now()
-    const elapsed = now - bucket.lastRefill
-
-    if (elapsed >= this.refillIntervalMs) {
-      // Full refill if interval passed
-      bucket.tokens = this.capacity
-      bucket.lastRefill = now
-    } else {
-      // Partial refill based on elapsed time
-      const tokensToAdd = (elapsed / this.refillIntervalMs) * this.capacity
-      bucket.tokens = Math.min(this.capacity, bucket.tokens + tokensToAdd)
-      bucket.lastRefill = now
-    }
-  }
-
-  /**
-   * Clear all buckets (for testing)
-   */
-  clearAll(): void {
-    this.buckets.clear()
-  }
-}
-
-/**
- * Create default rate limiter instance
- * 60 requests per minute per organization per integration
- */
-export function createRateLimiter(): RateLimiter {
-  return new InMemoryRateLimiter(DEFAULT_RATE_LIMIT_CAPACITY, DEFAULT_RATE_LIMIT_WINDOW_MS)
-}
+import type { RateLimiter } from './rate-limiter-types'
+import { DEFAULT_RATE_LIMIT_CAPACITY, DEFAULT_RATE_LIMIT_WINDOW_MS, STALE_BUCKET_MULTIPLIER } from '../constants/resilience'
+
+/**
+ * Token bucket state
+ */
+interface TokenBucket {
+  tokens: number
+  lastRefill: number
+}
+
+/**
+ * In-memory token bucket rate limiter
+ *
+ * Implements token bucket algorithm for rate limiting integration API calls.
+ * Default: 60 requests per minute per organization per integration.
+ *
+ * Pattern: Stateful class (justified - manages rate limit state)
+ *
+ * @example
+ * const limiter = new InMemoryRateLimiter(60, 60000) // 60 req/min
+ * const allowed = await limiter.allow('org123:gmail')
+ * if (!allowed) {
+ *   throw new ToolingError('rate_limit_exceeded', 'Rate limit exceeded')
+ * }
+ */
+export class InMemoryRateLimiter implements RateLimiter {
+  private buckets = new Map<string, TokenBucket>()
+  private lastEviction = Date.now()
+
+  /**
+   * @param capacity - Maximum tokens (requests) allowed
+   * @param refillIntervalMs - Refill interval in milliseconds
+   */
+  constructor(
+    private readonly capacity: number = DEFAULT_RATE_LIMIT_CAPACITY,
+    private readonly refillIntervalMs: number = DEFAULT_RATE_LIMIT_WINDOW_MS
+  ) {}
+
+  /**
+   * Check if request is allowed and consume token if available
+   */
+  async allow(key: string): Promise<boolean> {
+    const bucket = this.getOrCreateBucket(key)
+    this.refillBucket(bucket)
+
+    if (bucket.tokens > 0) {
+      bucket.tokens -= 1
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Get remaining tokens for key
+   */
+  async remaining(key: string): Promise<number> {
+    const bucket = this.getOrCreateBucket(key)
+    this.refillBucket(bucket)
+    return Math.floor(bucket.tokens)
+  }
+
+  /**
+   * Reset rate limit for key (removes bucket)
+   */
+  async reset(key: string): Promise<void> {
+    this.buckets.delete(key)
+  }
+
+  /**
+   * Get or create token bucket for key
+   * Lazily evicts stale buckets to prevent memory leaks
+   */
+  private getOrCreateBucket(key: string): TokenBucket {
+    this.evictStaleBuckets()
+
+    let bucket = this.buckets.get(key)
+    if (!bucket) {
+      bucket = {
+        tokens: this.capacity,
+        lastRefill: Date.now()
+      }
+      this.buckets.set(key, bucket)
+    }
+    return bucket
+  }
+
+  /**
+   * Evict buckets that haven't been accessed in 5x the refill interval
+   * Runs at most once per refill interval to avoid overhead
+   */
+  private evictStaleBuckets(): void {
+    const now = Date.now()
+    if (now - this.lastEviction < this.refillIntervalMs) return
+    this.lastEviction = now
+
+    const staleThreshold = this.refillIntervalMs * STALE_BUCKET_MULTIPLIER
+    for (const [key, bucket] of this.buckets) {
+      if (now - bucket.lastRefill > staleThreshold) {
+        this.buckets.delete(key)
+      }
+    }
+  }
+
+  /**
+   * Refill bucket based on time elapsed
+   * Uses linear refill: tokens added = (elapsed / interval) * capacity
+   */
+  private refillBucket(bucket: TokenBucket): void {
+    const now = Date.now()
+    const elapsed = now - bucket.lastRefill
+
+    if (elapsed >= this.refillIntervalMs) {
+      // Full refill if interval passed
+      bucket.tokens = this.capacity
+      bucket.lastRefill = now
+    } else {
+      // Partial refill based on elapsed time
+      const tokensToAdd = (elapsed / this.refillIntervalMs) * this.capacity
+      bucket.tokens = Math.min(this.capacity, bucket.tokens + tokensToAdd)
+      bucket.lastRefill = now
+    }
+  }
+
+  /**
+   * Clear all buckets (for testing)
+   */
+  clearAll(): void {
+    this.buckets.clear()
+  }
+}
+
+/**
+ * Create default rate limiter instance
+ * 60 requests per minute per organization per integration
+ */
+export function createRateLimiter(): RateLimiter {
+  return new InMemoryRateLimiter(DEFAULT_RATE_LIMIT_CAPACITY, DEFAULT_RATE_LIMIT_WINDOW_MS)
+}

package/src/platform/resilience/retry.ts

@@ -1,89 +1,89 @@
-import type { RetryPolicy } from './rate-limiter-types'
-import { ToolingError } from '../../execution/engine/tools/types'
-
-/**
- * Calculate retry delay with exponential backoff and jitter
- *
- * Formula: delay = min(maxDelay, initialDelay * 2^attempt) * (1 +/- jitter)
- *
- * @param attempt - Retry attempt number (0-indexed)
- * @param policy - Retry policy configuration
- * @returns Delay in milliseconds
- */
-export function calculateRetryDelay(attempt: number, policy: RetryPolicy): number {
-  const exponentialDelay = policy.initialDelayMs * Math.pow(2, attempt)
-  const cappedDelay = Math.min(policy.maxDelayMs, exponentialDelay)
-
-  // Add jitter: random factor between (1 - jitter) and (1 + jitter)
-  const jitterRange = policy.jitterFactor * 2
-  const jitterMultiplier = 1 - policy.jitterFactor + Math.random() * jitterRange
-
-  return Math.floor(cappedDelay * jitterMultiplier)
-}
-
-/**
- * Sleep for specified milliseconds
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-/**
- * Execute function with retry logic
- *
- * Retries on ToolingError where isRetryable() returns true.
- * Uses exponential backoff with jitter to prevent thundering herd.
- *
- * Pattern: Stateless function (processor pattern)
- *
- * @param fn - Function to execute
- * @param policy - Retry policy
- * @returns Function result
- * @throws ToolingError if all retries exhausted
- *
- * @example
- * const result = await withRetry(
- *   () => adapter.call('sendEmail', params, creds),
- *   DEFAULT_RETRY_POLICY
- * )
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  policy: RetryPolicy
-): Promise<T> {
-  let lastError: Error | undefined
-
-  for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
-    try {
-      return await fn()
-    } catch (error) {
-      lastError = error as Error
-
-      // Don't retry non-ToolingErrors (programming bugs, TypeErrors, etc.)
-      if (!(error instanceof ToolingError)) {
-        throw error
-      }
-
-      // Don't retry if the ToolingError is marked non-retryable
-      if (!error.isRetryable()) {
-        throw error
-      }
-
-      // Don't retry if max retries reached
-      if (attempt === policy.maxRetries) {
-        break
-      }
-
-      // Calculate delay and sleep before retry
-      const delay = calculateRetryDelay(attempt, policy)
-      await sleep(delay)
-    }
-  }
-
-  // All retries exhausted
-  throw new ToolingError(
-    'api_error',
-    `Failed after ${policy.maxRetries} retries: ${lastError?.message}`,
-    { originalError: lastError }
-  )
-}
+import type { RetryPolicy } from './rate-limiter-types'
+import { ToolingError } from '../../execution/engine/tools/types'
+
+/**
+ * Calculate retry delay with exponential backoff and jitter
+ *
+ * Formula: delay = min(maxDelay, initialDelay * 2^attempt) * (1 +/- jitter)
+ *
+ * @param attempt - Retry attempt number (0-indexed)
+ * @param policy - Retry policy configuration
+ * @returns Delay in milliseconds
+ */
+export function calculateRetryDelay(attempt: number, policy: RetryPolicy): number {
+  const exponentialDelay = policy.initialDelayMs * Math.pow(2, attempt)
+  const cappedDelay = Math.min(policy.maxDelayMs, exponentialDelay)
+
+  // Add jitter: random factor between (1 - jitter) and (1 + jitter)
+  const jitterRange = policy.jitterFactor * 2
+  const jitterMultiplier = 1 - policy.jitterFactor + Math.random() * jitterRange
+
+  return Math.floor(cappedDelay * jitterMultiplier)
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Execute function with retry logic
+ *
+ * Retries on ToolingError where isRetryable() returns true.
+ * Uses exponential backoff with jitter to prevent thundering herd.
+ *
+ * Pattern: Stateless function (processor pattern)
+ *
+ * @param fn - Function to execute
+ * @param policy - Retry policy
+ * @returns Function result
+ * @throws ToolingError if all retries exhausted
+ *
+ * @example
+ * const result = await withRetry(
+ *   () => adapter.call('sendEmail', params, creds),
+ *   DEFAULT_RETRY_POLICY
+ * )
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  policy: RetryPolicy
+): Promise<T> {
+  let lastError: Error | undefined
+
+  for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
+    try {
+      return await fn()
+    } catch (error) {
+      lastError = error as Error
+
+      // Don't retry non-ToolingErrors (programming bugs, TypeErrors, etc.)
+      if (!(error instanceof ToolingError)) {
+        throw error
+      }
+
+      // Don't retry if the ToolingError is marked non-retryable
+      if (!error.isRetryable()) {
+        throw error
+      }
+
+      // Don't retry if max retries reached
+      if (attempt === policy.maxRetries) {
+        break
+      }
+
+      // Calculate delay and sleep before retry
+      const delay = calculateRetryDelay(attempt, policy)
+      await sleep(delay)
+    }
+  }
+
+  // All retries exhausted
+  throw new ToolingError(
+    'api_error',
+    `Failed after ${policy.maxRetries} retries: ${lastError?.message}`,
+    { originalError: lastError }
+  )
+}

package/src/platform/resilience/timeout.ts

@@ -1,63 +1,63 @@
-/**
- * Timeout utility for wrapping external service calls.
- * Provides consistent timeout behavior with proper error classification.
- */
-
-import { ServiceTimeoutError } from './errors'
-
-/**
- * Wraps a Promise with a timeout. If the Promise doesn't resolve within
- * the specified time, throws a ServiceTimeoutError.
- *
- * @param promise - The Promise to wrap
- * @param timeoutMs - Timeout in milliseconds
- * @param service - Service name for error context (e.g., 'WorkOS', 'OpenAI')
- * @param operation - Optional operation name for error context (e.g., 'jwt_verify')
- * @returns The resolved value of the Promise
- * @throws ServiceTimeoutError if the timeout is exceeded
- *
- * @example
- * ```typescript
- * const user = await withTimeout(
- *   workos.userManagement.getUser(userId),
- *   SERVICE_TIMEOUTS.WORKOS_USER,
- *   'WorkOS',
- *   'user_lookup'
- * )
- * ```
- */
-export async function withTimeout<T>(
-  promise: Promise<T>,
-  timeoutMs: number,
-  service: string,
-  operation?: string
-): Promise<T> {
-  let timeoutId: ReturnType<typeof setTimeout>
-
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new ServiceTimeoutError(service, timeoutMs, operation))
-    }, timeoutMs)
-  })
-
-  try {
-    return await Promise.race([promise, timeoutPromise])
-  } finally {
-    clearTimeout(timeoutId!)
-  }
-}
-
-/**
- * Standard timeout values for different service operations.
- * These values are tuned for typical service behavior and cold start scenarios.
- */
-export const SERVICE_TIMEOUTS = {
-  /** WorkOS JWT verification - allows for cold starts */
-  WORKOS_JWT: 15_000,
-  /** WorkOS user lookup */
-  WORKOS_USER: 10_000,
-  /** Simple database queries */
-  DATABASE_SIMPLE: 10_000,
-  /** Complex database queries (JOINs, aggregations) */
-  DATABASE_COMPLEX: 30_000
-} as const
+/**
+ * Timeout utility for wrapping external service calls.
+ * Provides consistent timeout behavior with proper error classification.
+ */
+
+import { ServiceTimeoutError } from './errors'
+
+/**
+ * Wraps a Promise with a timeout. If the Promise doesn't resolve within
+ * the specified time, throws a ServiceTimeoutError.
+ *
+ * @param promise - The Promise to wrap
+ * @param timeoutMs - Timeout in milliseconds
+ * @param service - Service name for error context (e.g., 'WorkOS', 'OpenAI')
+ * @param operation - Optional operation name for error context (e.g., 'jwt_verify')
+ * @returns The resolved value of the Promise
+ * @throws ServiceTimeoutError if the timeout is exceeded
+ *
+ * @example
+ * ```typescript
+ * const user = await withTimeout(
+ *   workos.userManagement.getUser(userId),
+ *   SERVICE_TIMEOUTS.WORKOS_USER,
+ *   'WorkOS',
+ *   'user_lookup'
+ * )
+ * ```
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  service: string,
+  operation?: string
+): Promise<T> {
+  let timeoutId: ReturnType<typeof setTimeout>
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new ServiceTimeoutError(service, timeoutMs, operation))
+    }, timeoutMs)
+  })
+
+  try {
+    return await Promise.race([promise, timeoutPromise])
+  } finally {
+    clearTimeout(timeoutId!)
+  }
+}
+
+/**
+ * Standard timeout values for different service operations.
+ * These values are tuned for typical service behavior and cold start scenarios.
+ */
+export const SERVICE_TIMEOUTS = {
+  /** WorkOS JWT verification - allows for cold starts */
+  WORKOS_JWT: 15_000,
+  /** WorkOS user lookup */
+  WORKOS_USER: 10_000,
+  /** Simple database queries */
+  DATABASE_SIMPLE: 10_000,
+  /** Complex database queries (JOINs, aggregations) */
+  DATABASE_COMPLEX: 30_000
+} as const

package/src/platform/sse/events.ts

@@ -1,37 +1,37 @@
-/**
- * SSE Event Types - Central Union
- *
- * Aggregates all domain-specific SSE events into a type-safe union
- */
-
-import type { NotificationSSEEvent, NotificationCountUpdatedEvent } from '../../operations/notifications/sse-events'
-import type { ActivitySSEEvent, ActivityCreatedEvent, ActivityConnectedEvent } from '../../operations/activities/sse-events'
-import type { CommandQueueSSEEvent, CommandQueueTaskUpdatedEvent, CommandQueueConnectedEvent } from '../../commands/queue/sse-events'
-import type { DeliverySSEEvent, DeliveryConnectedEvent, DeliveryEntityChangedEvent } from '../../business/projects/sse-events'
-import type {
-  ExecutionSSEEvent,
-  ExecutionStartedEvent,
-  ExecutionLogEvent,
-  ExecutionCompleteEvent,
-  ExecutionConnectedEvent
-} from '../../execution/core/sse-executions'
-
-// Re-export domain-specific event types
-export type { NotificationSSEEvent, NotificationCountUpdatedEvent }
-export type { ActivitySSEEvent, ActivityCreatedEvent, ActivityConnectedEvent }
-export type { CommandQueueSSEEvent, CommandQueueTaskUpdatedEvent, CommandQueueConnectedEvent }
-export type { DeliverySSEEvent, DeliveryConnectedEvent, DeliveryEntityChangedEvent }
-export type { ExecutionSSEEvent, ExecutionStartedEvent, ExecutionLogEvent, ExecutionCompleteEvent, ExecutionConnectedEvent }
-
-/**
- * Union of all application-level SSE events across all domains
- *
- * Use this for generic SSE handling that needs to support all event types.
- * For domain-specific handling, use NotificationSSEEvent, ActivitySSEEvent, ExecutionSSEEvent, etc.
- */
-export type AppSSEEvent =
-  | NotificationSSEEvent
-  | ActivitySSEEvent
-  | CommandQueueSSEEvent
-  | DeliverySSEEvent
-  | ExecutionSSEEvent
+/**
+ * SSE Event Types - Central Union
+ *
+ * Aggregates all domain-specific SSE events into a type-safe union
+ */
+
+import type { NotificationSSEEvent, NotificationCountUpdatedEvent } from '../../operations/notifications/sse-events'
+import type { ActivitySSEEvent, ActivityCreatedEvent, ActivityConnectedEvent } from '../../operations/activities/sse-events'
+import type { CommandQueueSSEEvent, CommandQueueTaskUpdatedEvent, CommandQueueConnectedEvent } from '../../commands/queue/sse-events'
+import type { DeliverySSEEvent, DeliveryConnectedEvent, DeliveryEntityChangedEvent } from '../../business/projects/sse-events'
+import type {
+  ExecutionSSEEvent,
+  ExecutionStartedEvent,
+  ExecutionLogEvent,
+  ExecutionCompleteEvent,
+  ExecutionConnectedEvent
+} from '../../execution/core/sse-executions'
+
+// Re-export domain-specific event types
+export type { NotificationSSEEvent, NotificationCountUpdatedEvent }
+export type { ActivitySSEEvent, ActivityCreatedEvent, ActivityConnectedEvent }
+export type { CommandQueueSSEEvent, CommandQueueTaskUpdatedEvent, CommandQueueConnectedEvent }
+export type { DeliverySSEEvent, DeliveryConnectedEvent, DeliveryEntityChangedEvent }
+export type { ExecutionSSEEvent, ExecutionStartedEvent, ExecutionLogEvent, ExecutionCompleteEvent, ExecutionConnectedEvent }
+
+/**
+ * Union of all application-level SSE events across all domains
+ *
+ * Use this for generic SSE handling that needs to support all event types.
+ * For domain-specific handling, use NotificationSSEEvent, ActivitySSEEvent, ExecutionSSEEvent, etc.
+ */
+export type AppSSEEvent =
+  | NotificationSSEEvent
+  | ActivitySSEEvent
+  | CommandQueueSSEEvent
+  | DeliverySSEEvent
+  | ExecutionSSEEvent

package/src/platform/sse/index.ts

@@ -1,7 +1,7 @@
-/**
- * SSE (Server-Sent Events) Types and Utilities
- *
- * Central export point for all SSE-related types
- */
-
-export * from './events'
+/**
+ * SSE (Server-Sent Events) Types and Utilities
+ *
+ * Central export point for all SSE-related types
+ */
+
+export * from './events'