@bota-dev/react-native-sdk 0.0.2

package/src/upload/UploadQueue.ts

@@ -0,0 +1,310 @@
+/**
+ * Upload Queue - Manages persistent upload queue with retry logic
+ */
+
+import EventEmitter from 'eventemitter3';
+
+import type { UploadTask } from '../models/Recording';
+import { StorageManager, generateTaskId } from '../storage/StorageManager';
+import { S3Uploader } from './S3Uploader';
+import { shouldContinueRetrying } from '../utils/retry';
+import { logger } from '../utils/logger';
+
+const log = logger.tag('UploadQueue');
+
+/**
+ * Events emitted by UploadQueue
+ */
+interface UploadQueueEvents {
+  taskAdded: (task: UploadTask) => void;
+  taskUpdated: (task: UploadTask) => void;
+  taskCompleted: (taskId: string, recordingId: string) => void;
+  taskFailed: (taskId: string, error: Error) => void;
+  uploadProgress: (taskId: string, progress: number) => void;
+  queueEmpty: () => void;
+}
+
+/**
+ * Upload Queue configuration
+ */
+export interface UploadQueueConfig {
+  /** Maximum concurrent uploads (default: 2) */
+  maxConcurrent?: number;
+  /** Maximum retry attempts (default: 6) */
+  maxRetries?: number;
+  /** Auto-start processing (default: true) */
+  autoStart?: boolean;
+}
+
+/**
+ * Upload Queue class
+ */
+export class UploadQueue extends EventEmitter<UploadQueueEvents> {
+  private storage: StorageManager;
+  private uploader: S3Uploader;
+  private maxConcurrent: number;
+  private maxRetries: number;
+  private activeUploads: Set<string> = new Set();
+  private isPaused = false;
+  private isProcessing = false;
+  private abortControllers: Map<string, AbortController> = new Map();
+
+  constructor(storage: StorageManager, config: UploadQueueConfig = {}) {
+    super();
+    this.storage = storage;
+    this.uploader = new S3Uploader();
+    this.maxConcurrent = config.maxConcurrent ?? 2;
+    this.maxRetries = config.maxRetries ?? 6;
+
+    if (config.autoStart !== false) {
+      this.processQueue();
+    }
+  }
+
+  /**
+   * Add a new upload task to the queue
+   */
+  async enqueue(params: {
+    recordingId: string;
+    deviceId: string;
+    localPath: string;
+    uploadUrl: string;
+    uploadToken: string;
+    completeUrl: string;
+  }): Promise<UploadTask> {
+    const task: UploadTask = {
+      id: generateTaskId(),
+      recordingId: params.recordingId,
+      deviceId: params.deviceId,
+      localPath: params.localPath,
+      uploadUrl: params.uploadUrl,
+      uploadToken: params.uploadToken,
+      completeUrl: params.completeUrl,
+      status: 'pending',
+      retryCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    await this.storage.addUploadTask(task);
+    this.emit('taskAdded', task);
+
+    log.info('Task enqueued', { taskId: task.id, recordingId: task.recordingId });
+
+    // Trigger queue processing
+    this.processQueue();
+
+    return task;
+  }
+
+  /**
+   * Cancel a specific upload task
+   */
+  async cancel(taskId: string): Promise<void> {
+    log.info('Cancelling task', { taskId });
+
+    // Abort if currently uploading
+    const controller = this.abortControllers.get(taskId);
+    if (controller) {
+      controller.abort();
+      this.abortControllers.delete(taskId);
+    }
+
+    // Remove from active uploads
+    this.activeUploads.delete(taskId);
+
+    // Remove from queue
+    await this.storage.removeUploadTask(taskId);
+  }
+
+  /**
+   * Cancel all uploads
+   */
+  async cancelAll(): Promise<void> {
+    log.info('Cancelling all uploads');
+
+    // Abort all active uploads
+    for (const controller of this.abortControllers.values()) {
+      controller.abort();
+    }
+    this.abortControllers.clear();
+    this.activeUploads.clear();
+
+    // Clear queue
+    await this.storage.clearAllTasks();
+    this.emit('queueEmpty');
+  }
+
+  /**
+   * Pause queue processing
+   */
+  pause(): void {
+    log.info('Pausing upload queue');
+    this.isPaused = true;
+  }
+
+  /**
+   * Resume queue processing
+   */
+  resume(): void {
+    log.info('Resuming upload queue');
+    this.isPaused = false;
+    this.processQueue();
+  }
+
+  /**
+   * Retry all failed uploads
+   */
+  async retryFailed(): Promise<void> {
+    log.info('Retrying failed uploads');
+
+    const failedTasks = this.storage.getFailedUploads();
+    for (const task of failedTasks) {
+      if (task.retryCount < this.maxRetries) {
+        await this.storage.updateTaskStatus(task.id, 'pending');
+      }
+    }
+
+    this.processQueue();
+  }
+
+  /**
+   * Get all pending tasks
+   */
+  getPendingTasks(): UploadTask[] {
+    return this.storage.getPendingUploads();
+  }
+
+  /**
+   * Get all tasks
+   */
+  getAllTasks(): UploadTask[] {
+    return this.storage.getUploadQueue();
+  }
+
+  /**
+   * Process the upload queue
+   */
+  private async processQueue(): Promise<void> {
+    if (this.isPaused || this.isProcessing) {
+      return;
+    }
+
+    this.isProcessing = true;
+
+    try {
+      while (!this.isPaused) {
+        // Check if we can start more uploads
+        if (this.activeUploads.size >= this.maxConcurrent) {
+          break;
+        }
+
+        // Get next pending task
+        const pendingTasks = this.storage.getPendingUploads();
+        const nextTask = pendingTasks.find(
+          (t) => !this.activeUploads.has(t.id) && t.status === 'pending'
+        );
+
+        if (!nextTask) {
+          // No more tasks to process
+          if (this.activeUploads.size === 0) {
+            this.emit('queueEmpty');
+          }
+          break;
+        }
+
+        // Start upload in background
+        this.processTask(nextTask);
+      }
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  /**
+   * Process a single upload task
+   */
+  private async processTask(task: UploadTask): Promise<void> {
+    this.activeUploads.add(task.id);
+
+    const abortController = new AbortController();
+    this.abortControllers.set(task.id, abortController);
+
+    try {
+      // Update status to uploading
+      await this.storage.updateTaskStatus(task.id, 'uploading');
+      this.emit('taskUpdated', { ...task, status: 'uploading' });
+
+      log.info('Starting upload', { taskId: task.id, recordingId: task.recordingId });
+
+      // Load the audio data
+      const audioData = await this.storage.loadRecordingData(task.localPath);
+
+      // Upload to S3
+      await this.uploader.upload(audioData, task.uploadUrl, {
+        onProgress: (progress) => {
+          this.emit('uploadProgress', task.id, progress);
+        },
+        abortSignal: abortController.signal,
+      });
+
+      // Notify completion
+      await this.uploader.notifyCompletion(
+        task.completeUrl,
+        task.recordingId,
+        task.uploadToken
+      );
+
+      // Mark as completed
+      await this.storage.updateTaskStatus(task.id, 'completed');
+
+      // Clean up local file
+      await this.storage.deleteRecordingData(task.localPath);
+
+      log.info('Upload completed', { taskId: task.id, recordingId: task.recordingId });
+
+      this.emit('taskCompleted', task.id, task.recordingId);
+    } catch (error) {
+      const err = error as Error;
+      log.error('Upload failed', err, { taskId: task.id });
+
+      // Check if we should retry
+      if (
+        task.retryCount < this.maxRetries &&
+        shouldContinueRetrying(task.createdAt)
+      ) {
+        await this.storage.incrementRetryCount(task.id);
+        await this.storage.updateTaskStatus(task.id, 'pending', err.message);
+        log.info('Task will be retried', {
+          taskId: task.id,
+          retryCount: task.retryCount + 1,
+        });
+      } else {
+        await this.storage.updateTaskStatus(task.id, 'failed', err.message);
+        this.emit('taskFailed', task.id, err);
+      }
+    } finally {
+      this.activeUploads.delete(task.id);
+      this.abortControllers.delete(task.id);
+
+      // Process next task
+      this.processQueue();
+    }
+  }
+
+  /**
+   * Clean up resources
+   */
+  destroy(): void {
+    this.isPaused = true;
+
+    // Abort all active uploads
+    for (const controller of this.abortControllers.values()) {
+      controller.abort();
+    }
+    this.abortControllers.clear();
+    this.activeUploads.clear();
+
+    this.removeAllListeners();
+  }
+}

package/src/upload/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Upload module exports
+ */
+
+export { S3Uploader, type UploadProgressCallback, type UploadOptions } from './S3Uploader';
+export { UploadQueue, type UploadQueueConfig } from './UploadQueue';

package/src/utils/errors.ts

@@ -0,0 +1,310 @@
+/**
+ * Custom error types for the Bota SDK
+ */
+
+/**
+ * Base error class for all Bota SDK errors
+ */
+export class BotaError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly cause?: Error
+  ) {
+    super(message);
+    this.name = 'BotaError';
+    Object.setPrototypeOf(this, BotaError.prototype);
+  }
+}
+
+/**
+ * Bluetooth-related errors
+ */
+export class BluetoothError extends BotaError {
+  constructor(message: string, code: string, cause?: Error) {
+    super(message, code, cause);
+    this.name = 'BluetoothError';
+    Object.setPrototypeOf(this, BluetoothError.prototype);
+  }
+
+  static unavailable(): BluetoothError {
+    return new BluetoothError(
+      'Bluetooth is not available on this device',
+      'BLUETOOTH_UNAVAILABLE'
+    );
+  }
+
+  static unauthorized(): BluetoothError {
+    return new BluetoothError(
+      'Bluetooth permission not granted',
+      'BLUETOOTH_UNAUTHORIZED'
+    );
+  }
+
+  static poweredOff(): BluetoothError {
+    return new BluetoothError('Bluetooth is powered off', 'BLUETOOTH_OFF');
+  }
+}
+
+/**
+ * Device-related errors
+ */
+export class DeviceError extends BotaError {
+  constructor(
+    message: string,
+    code: string,
+    public readonly deviceId?: string,
+    cause?: Error
+  ) {
+    super(message, code, cause);
+    this.name = 'DeviceError';
+    Object.setPrototypeOf(this, DeviceError.prototype);
+  }
+
+  static notFound(deviceId: string): DeviceError {
+    return new DeviceError(
+      `Device ${deviceId} not found`,
+      'DEVICE_NOT_FOUND',
+      deviceId
+    );
+  }
+
+  static connectionFailed(deviceId: string, cause?: Error): DeviceError {
+    return new DeviceError(
+      `Failed to connect to device ${deviceId}`,
+      'CONNECTION_FAILED',
+      deviceId,
+      cause
+    );
+  }
+
+  static connectionLost(deviceId: string, during?: string): DeviceError {
+    const message = during
+      ? `Connection to device ${deviceId} lost during ${during}`
+      : `Connection to device ${deviceId} lost`;
+    return new DeviceError(message, 'CONNECTION_LOST', deviceId);
+  }
+
+  static bondingFailed(deviceId: string, cause?: Error): DeviceError {
+    return new DeviceError(
+      `Bonding failed for device ${deviceId}`,
+      'BONDING_FAILED',
+      deviceId,
+      cause
+    );
+  }
+
+  static notConnected(deviceId: string): DeviceError {
+    return new DeviceError(
+      `Device ${deviceId} is not connected`,
+      'NOT_CONNECTED',
+      deviceId
+    );
+  }
+
+  static alreadyConnected(deviceId: string): DeviceError {
+    return new DeviceError(
+      `Device ${deviceId} is already connected`,
+      'ALREADY_CONNECTED',
+      deviceId
+    );
+  }
+}
+
+/**
+ * Provisioning-related errors
+ */
+export class ProvisioningError extends BotaError {
+  constructor(
+    message: string,
+    code: string,
+    public readonly deviceId?: string,
+    cause?: Error
+  ) {
+    super(message, code, cause);
+    this.name = 'ProvisioningError';
+    Object.setPrototypeOf(this, ProvisioningError.prototype);
+  }
+
+  static invalidToken(deviceId: string): ProvisioningError {
+    return new ProvisioningError(
+      'Device rejected the token as invalid',
+      'INVALID_TOKEN',
+      deviceId
+    );
+  }
+
+  static storageError(deviceId: string): ProvisioningError {
+    return new ProvisioningError(
+      'Device failed to store the token',
+      'STORAGE_ERROR',
+      deviceId
+    );
+  }
+
+  static chunkError(deviceId: string): ProvisioningError {
+    return new ProvisioningError(
+      'Token chunk transfer failed',
+      'CHUNK_ERROR',
+      deviceId
+    );
+  }
+
+  static alreadyProvisioned(deviceId: string): ProvisioningError {
+    return new ProvisioningError(
+      'Device is already provisioned',
+      'ALREADY_PROVISIONED',
+      deviceId
+    );
+  }
+
+  static timeout(deviceId: string): ProvisioningError {
+    return new ProvisioningError(
+      'Provisioning timed out waiting for device response',
+      'PROVISIONING_TIMEOUT',
+      deviceId
+    );
+  }
+}
+
+/**
+ * Transfer-related errors
+ */
+export class TransferError extends BotaError {
+  constructor(
+    message: string,
+    code: string,
+    public readonly recordingUuid?: string,
+    cause?: Error
+  ) {
+    super(message, code, cause);
+    this.name = 'TransferError';
+    Object.setPrototypeOf(this, TransferError.prototype);
+  }
+
+  static recordingNotFound(uuid: string): TransferError {
+    return new TransferError(
+      `Recording ${uuid} not found on device`,
+      'RECORDING_NOT_FOUND',
+      uuid
+    );
+  }
+
+  static checksumMismatch(uuid: string): TransferError {
+    return new TransferError(
+      `Checksum mismatch for recording ${uuid}`,
+      'CHECKSUM_MISMATCH',
+      uuid
+    );
+  }
+
+  static interrupted(uuid: string, cause?: Error): TransferError {
+    return new TransferError(
+      `Transfer interrupted for recording ${uuid}`,
+      'TRANSFER_INTERRUPTED',
+      uuid,
+      cause
+    );
+  }
+
+  static timeout(uuid: string): TransferError {
+    return new TransferError(
+      `Transfer timed out for recording ${uuid}`,
+      'TRANSFER_TIMEOUT',
+      uuid
+    );
+  }
+
+  static deviceError(uuid: string, errorCode: number): TransferError {
+    return new TransferError(
+      `Device error (code: ${errorCode}) during transfer of ${uuid}`,
+      'DEVICE_ERROR',
+      uuid
+    );
+  }
+}
+
+/**
+ * Upload-related errors
+ */
+export class UploadError extends BotaError {
+  constructor(
+    message: string,
+    code: string,
+    public readonly taskId?: string,
+    cause?: Error
+  ) {
+    super(message, code, cause);
+    this.name = 'UploadError';
+    Object.setPrototypeOf(this, UploadError.prototype);
+  }
+
+  static urlExpired(taskId: string): UploadError {
+    return new UploadError(
+      'Upload URL has expired',
+      'URL_EXPIRED',
+      taskId
+    );
+  }
+
+  static networkUnavailable(): UploadError {
+    return new UploadError(
+      'Network is not available',
+      'NETWORK_UNAVAILABLE'
+    );
+  }
+
+  static uploadFailed(taskId: string, cause?: Error): UploadError {
+    return new UploadError(
+      `Upload failed for task ${taskId}`,
+      'UPLOAD_FAILED',
+      taskId,
+      cause
+    );
+  }
+
+  static completionFailed(taskId: string, cause?: Error): UploadError {
+    return new UploadError(
+      `Failed to notify completion for task ${taskId}`,
+      'COMPLETION_FAILED',
+      taskId,
+      cause
+    );
+  }
+}
+
+/**
+ * SDK state errors
+ */
+export class SdkError extends BotaError {
+  constructor(message: string, code: string, cause?: Error) {
+    super(message, code, cause);
+    this.name = 'SdkError';
+    Object.setPrototypeOf(this, SdkError.prototype);
+  }
+
+  static notInitialized(): SdkError {
+    return new SdkError(
+      'SDK has not been initialized. Call BotaClient.configure() first.',
+      'NOT_INITIALIZED'
+    );
+  }
+
+  static invalidState(expected: string, actual: string): SdkError {
+    return new SdkError(
+      `Invalid state: expected ${expected}, got ${actual}`,
+      'INVALID_STATE'
+    );
+  }
+
+  static timeout(operation: string): SdkError {
+    return new SdkError(`Operation timed out: ${operation}`, 'TIMEOUT');
+  }
+}
+
+/**
+ * Type guard to check if an error is a BotaError
+ */
+export function isBotaError(error: unknown): error is BotaError {
+  return error instanceof BotaError;
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Utils module exports
+ */
+
+export * from './errors';
+export { logger } from './logger';
+export * from './retry';