@bota-dev/react-native-sdk 0.0.2

package/src/utils/logger.ts

@@ -0,0 +1,137 @@
+/**
+ * Logger utility for the Bota SDK
+ */
+
+import type { LogLevel } from '../models/Status';
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4,
+};
+
+/**
+ * Logger class with configurable log levels
+ */
+class Logger {
+  private level: LogLevel = 'warn';
+  private prefix = '[BotaSDK]';
+
+  /**
+   * Set the log level
+   */
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  /**
+   * Get the current log level
+   */
+  getLevel(): LogLevel {
+    return this.level;
+  }
+
+  /**
+   * Check if a log level should be output
+   */
+  private shouldLog(level: LogLevel): boolean {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+
+  /**
+   * Format a log message with optional context
+   */
+  private format(
+    level: string,
+    message: string,
+    context?: Record<string, unknown>
+  ): string {
+    const timestamp = new Date().toISOString();
+    const contextStr = context ? ` ${JSON.stringify(context)}` : '';
+    return `${timestamp} ${this.prefix} [${level.toUpperCase()}] ${message}${contextStr}`;
+  }
+
+  /**
+   * Log a debug message
+   */
+  debug(message: string, context?: Record<string, unknown>): void {
+    if (this.shouldLog('debug')) {
+      console.debug(this.format('debug', message, context));
+    }
+  }
+
+  /**
+   * Log an info message
+   */
+  info(message: string, context?: Record<string, unknown>): void {
+    if (this.shouldLog('info')) {
+      console.info(this.format('info', message, context));
+    }
+  }
+
+  /**
+   * Log a warning message
+   */
+  warn(message: string, context?: Record<string, unknown>): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.format('warn', message, context));
+    }
+  }
+
+  /**
+   * Log an error message
+   */
+  error(message: string, error?: Error, context?: Record<string, unknown>): void {
+    if (this.shouldLog('error')) {
+      const fullContext = error
+        ? { ...context, error: error.message, stack: error.stack }
+        : context;
+      console.error(this.format('error', message, fullContext));
+    }
+  }
+
+  /**
+   * Create a child logger with a specific tag
+   */
+  tag(tag: string): TaggedLogger {
+    return new TaggedLogger(this, tag);
+  }
+}
+
+/**
+ * Tagged logger for component-specific logging
+ */
+class TaggedLogger {
+  constructor(
+    private parent: Logger,
+    private tag: string
+  ) {}
+
+  debug(message: string, context?: Record<string, unknown>): void {
+    this.parent.debug(`[${this.tag}] ${message}`, context);
+  }
+
+  info(message: string, context?: Record<string, unknown>): void {
+    this.parent.info(`[${this.tag}] ${message}`, context);
+  }
+
+  warn(message: string, context?: Record<string, unknown>): void {
+    this.parent.warn(`[${this.tag}] ${message}`, context);
+  }
+
+  error(message: string, error?: Error, context?: Record<string, unknown>): void {
+    this.parent.error(`[${this.tag}] ${message}`, error, context);
+  }
+}
+
+/**
+ * Singleton logger instance
+ */
+export const logger = new Logger();
+
+/**
+ * Export types for external use
+ */
+export type { TaggedLogger };

package/src/utils/retry.ts

@@ -0,0 +1,177 @@
+/**
+ * Retry utility with exponential backoff
+ */
+
+import { logger } from './logger';
+
+const log = logger.tag('Retry');
+
+/**
+ * Retry configuration options
+ */
+export interface RetryOptions {
+  /** Maximum number of retry attempts (default: 6) */
+  maxAttempts?: number;
+  /** Base delay in milliseconds (default: 1000) */
+  baseDelayMs?: number;
+  /** Maximum delay in milliseconds (default: 14400000 = 4 hours) */
+  maxDelayMs?: number;
+  /** Backoff multiplier (default: 2) */
+  backoffMultiplier?: number;
+  /** Add jitter to delays (default: true) */
+  jitter?: boolean;
+  /** Callback for each retry attempt */
+  onRetry?: (attempt: number, error: Error, delayMs: number) => void;
+  /** Predicate to determine if error is retryable (default: all errors) */
+  isRetryable?: (error: Error) => boolean;
+}
+
+/**
+ * Default retry delays based on Bota spec:
+ * Attempt 1: Immediate
+ * Attempt 2: 30 seconds
+ * Attempt 3: 2 minutes
+ * Attempt 4: 10 minutes
+ * Attempt 5: 1 hour
+ * Attempt 6: 4 hours
+ */
+export const DEFAULT_RETRY_DELAYS = [
+  0, // Immediate
+  30 * 1000, // 30 seconds
+  2 * 60 * 1000, // 2 minutes
+  10 * 60 * 1000, // 10 minutes
+  60 * 60 * 1000, // 1 hour
+  4 * 60 * 60 * 1000, // 4 hours
+];
+
+/**
+ * Calculate delay for a retry attempt using exponential backoff
+ */
+export function calculateDelay(
+  attempt: number,
+  options: RetryOptions = {}
+): number {
+  const {
+    baseDelayMs = 1000,
+    maxDelayMs = 14400000,
+    backoffMultiplier = 2,
+    jitter = true,
+  } = options;
+
+  // Use predefined delays for upload retries
+  if (attempt < DEFAULT_RETRY_DELAYS.length) {
+    const delay = DEFAULT_RETRY_DELAYS[attempt];
+    if (jitter && delay > 0) {
+      // Add up to 10% jitter
+      return delay + Math.random() * delay * 0.1;
+    }
+    return delay;
+  }
+
+  // Fall back to exponential backoff for additional retries
+  let delay = baseDelayMs * Math.pow(backoffMultiplier, attempt);
+  delay = Math.min(delay, maxDelayMs);
+
+  if (jitter) {
+    // Add up to 10% jitter
+    delay = delay + Math.random() * delay * 0.1;
+  }
+
+  return Math.floor(delay);
+}
+
+/**
+ * Sleep for a specified duration
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Execute a function with retry logic
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {}
+): Promise<T> {
+  const {
+    maxAttempts = 6,
+    onRetry,
+    isRetryable = () => true,
+  } = options;
+
+  let lastError: Error | undefined;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+
+      // Check if error is retryable
+      if (!isRetryable(lastError)) {
+        log.debug('Error is not retryable, throwing immediately', {
+          attempt,
+          error: lastError.message,
+        });
+        throw lastError;
+      }
+
+      // Check if we have more attempts
+      if (attempt >= maxAttempts - 1) {
+        log.warn('Max retry attempts reached', {
+          attempt: attempt + 1,
+          maxAttempts,
+          error: lastError.message,
+        });
+        throw lastError;
+      }
+
+      // Calculate delay
+      const delayMs = calculateDelay(attempt, options);
+
+      log.debug('Retrying after error', {
+        attempt: attempt + 1,
+        maxAttempts,
+        delayMs,
+        error: lastError.message,
+      });
+
+      // Notify callback
+      if (onRetry) {
+        onRetry(attempt + 1, lastError, delayMs);
+      }
+
+      // Wait before retrying
+      if (delayMs > 0) {
+        await sleep(delayMs);
+      }
+    }
+  }
+
+  // This should never be reached, but TypeScript needs it
+  throw lastError ?? new Error('Retry failed');
+}
+
+/**
+ * Create a retryable wrapper for a function
+ */
+export function makeRetryable<T extends (...args: unknown[]) => Promise<unknown>>(
+  fn: T,
+  options: RetryOptions = {}
+): T {
+  return (async (...args: Parameters<T>): Promise<ReturnType<T>> => {
+    return withRetry(() => fn(...args) as Promise<ReturnType<T>>, options);
+  }) as T;
+}
+
+/**
+ * Check if we should continue retrying based on total time elapsed
+ */
+export function shouldContinueRetrying(
+  startTime: Date,
+  maxDurationMs: number = 24 * 60 * 60 * 1000 // 24 hours
+): boolean {
+  const elapsed = Date.now() - startTime.getTime();
+  return elapsed < maxDurationMs;
+}