@bota-dev/react-native-sdk 0.0.2

package/src/storage/StorageManager.ts

@@ -0,0 +1,343 @@
+/**
+ * Storage Manager - Local persistence for recordings and upload queue
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Buffer } from 'buffer';
+
+import type { UploadTask, UploadTaskStatus } from '../models/Recording';
+import { logger } from '../utils/logger';
+
+const log = logger.tag('StorageManager');
+
+// Storage keys
+const STORAGE_PREFIX = '@bota_sdk:';
+const UPLOAD_QUEUE_KEY = `${STORAGE_PREFIX}upload_queue`;
+const SDK_STATE_KEY = `${STORAGE_PREFIX}sdk_state`;
+
+/**
+ * SDK persistent state
+ */
+interface SdkState {
+  lastSyncTimes: Record<string, number>; // deviceId -> timestamp
+  deviceInfo: Record<string, { serialNumber: string; firmwareVersion: string }>;
+}
+
+/**
+ * Storage Manager class
+ */
+export class StorageManager {
+  private uploadQueue: UploadTask[] = [];
+  private sdkState: SdkState = {
+    lastSyncTimes: {},
+    deviceInfo: {},
+  };
+  private isInitialized = false;
+
+  /**
+   * Initialize storage manager
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    log.debug('Initializing StorageManager');
+
+    try {
+      // Load upload queue
+      const queueData = await AsyncStorage.getItem(UPLOAD_QUEUE_KEY);
+      if (queueData) {
+        this.uploadQueue = JSON.parse(queueData);
+        // Restore dates
+        this.uploadQueue = this.uploadQueue.map((task) => ({
+          ...task,
+          createdAt: new Date(task.createdAt),
+          updatedAt: new Date(task.updatedAt),
+        }));
+      }
+
+      // Load SDK state
+      const stateData = await AsyncStorage.getItem(SDK_STATE_KEY);
+      if (stateData) {
+        this.sdkState = JSON.parse(stateData);
+      }
+
+      this.isInitialized = true;
+      log.info('StorageManager initialized', {
+        pendingUploads: this.uploadQueue.length,
+      });
+    } catch (error) {
+      log.error('Failed to initialize storage', error as Error);
+      // Continue with empty state
+      this.isInitialized = true;
+    }
+  }
+
+  // Upload Queue Methods
+
+  /**
+   * Get all upload tasks
+   */
+  getUploadQueue(): UploadTask[] {
+    return [...this.uploadQueue];
+  }
+
+  /**
+   * Get pending upload tasks
+   */
+  getPendingUploads(): UploadTask[] {
+    return this.uploadQueue.filter(
+      (task) => task.status === 'pending' || task.status === 'uploading'
+    );
+  }
+
+  /**
+   * Get failed upload tasks
+   */
+  getFailedUploads(): UploadTask[] {
+    return this.uploadQueue.filter((task) => task.status === 'failed');
+  }
+
+  /**
+   * Add a task to the upload queue
+   */
+  async addUploadTask(task: UploadTask): Promise<void> {
+    log.debug('Adding upload task', { taskId: task.id, recordingId: task.recordingId });
+
+    this.uploadQueue.push(task);
+    await this.saveUploadQueue();
+  }
+
+  /**
+   * Update an upload task
+   */
+  async updateUploadTask(
+    taskId: string,
+    updates: Partial<UploadTask>
+  ): Promise<void> {
+    const index = this.uploadQueue.findIndex((t) => t.id === taskId);
+    if (index === -1) {
+      log.warn('Upload task not found', { taskId });
+      return;
+    }
+
+    this.uploadQueue[index] = {
+      ...this.uploadQueue[index],
+      ...updates,
+      updatedAt: new Date(),
+    };
+
+    await this.saveUploadQueue();
+  }
+
+  /**
+   * Update task status
+   */
+  async updateTaskStatus(
+    taskId: string,
+    status: UploadTaskStatus,
+    errorMessage?: string
+  ): Promise<void> {
+    await this.updateUploadTask(taskId, { status, errorMessage });
+  }
+
+  /**
+   * Increment retry count for a task
+   */
+  async incrementRetryCount(taskId: string): Promise<void> {
+    const task = this.uploadQueue.find((t) => t.id === taskId);
+    if (task) {
+      await this.updateUploadTask(taskId, { retryCount: task.retryCount + 1 });
+    }
+  }
+
+  /**
+   * Remove a task from the queue
+   */
+  async removeUploadTask(taskId: string): Promise<void> {
+    log.debug('Removing upload task', { taskId });
+
+    this.uploadQueue = this.uploadQueue.filter((t) => t.id !== taskId);
+    await this.saveUploadQueue();
+  }
+
+  /**
+   * Clear all completed tasks
+   */
+  async clearCompletedTasks(): Promise<void> {
+    this.uploadQueue = this.uploadQueue.filter(
+      (t) => t.status !== 'completed'
+    );
+    await this.saveUploadQueue();
+  }
+
+  /**
+   * Clear all tasks
+   */
+  async clearAllTasks(): Promise<void> {
+    this.uploadQueue = [];
+    await this.saveUploadQueue();
+  }
+
+  /**
+   * Get a specific upload task
+   */
+  getUploadTask(taskId: string): UploadTask | undefined {
+    return this.uploadQueue.find((t) => t.id === taskId);
+  }
+
+  /**
+   * Save upload queue to storage
+   */
+  private async saveUploadQueue(): Promise<void> {
+    try {
+      await AsyncStorage.setItem(
+        UPLOAD_QUEUE_KEY,
+        JSON.stringify(this.uploadQueue)
+      );
+    } catch (error) {
+      log.error('Failed to save upload queue', error as Error);
+    }
+  }
+
+  // SDK State Methods
+
+  /**
+   * Get last sync time for a device
+   */
+  getLastSyncTime(deviceId: string): Date | null {
+    const timestamp = this.sdkState.lastSyncTimes[deviceId];
+    return timestamp ? new Date(timestamp) : null;
+  }
+
+  /**
+   * Set last sync time for a device
+   */
+  async setLastSyncTime(deviceId: string, time: Date = new Date()): Promise<void> {
+    this.sdkState.lastSyncTimes[deviceId] = time.getTime();
+    await this.saveSdkState();
+  }
+
+  /**
+   * Get cached device info
+   */
+  getDeviceInfo(
+    deviceId: string
+  ): { serialNumber: string; firmwareVersion: string } | undefined {
+    return this.sdkState.deviceInfo[deviceId];
+  }
+
+  /**
+   * Cache device info
+   */
+  async setDeviceInfo(
+    deviceId: string,
+    info: { serialNumber: string; firmwareVersion: string }
+  ): Promise<void> {
+    this.sdkState.deviceInfo[deviceId] = info;
+    await this.saveSdkState();
+  }
+
+  /**
+   * Save SDK state to storage
+   */
+  private async saveSdkState(): Promise<void> {
+    try {
+      await AsyncStorage.setItem(SDK_STATE_KEY, JSON.stringify(this.sdkState));
+    } catch (error) {
+      log.error('Failed to save SDK state', error as Error);
+    }
+  }
+
+  // Recording File Methods
+  // Note: For actual file storage, we'd need react-native-fs or similar
+  // For now, we'll store base64 encoded audio in AsyncStorage for small files
+
+  /**
+   * Save recording data locally
+   */
+  async saveRecordingData(
+    deviceId: string,
+    recordingUuid: string,
+    data: Buffer
+  ): Promise<string> {
+    const key = `${STORAGE_PREFIX}recording:${deviceId}:${recordingUuid}`;
+
+    try {
+      // Store as base64 (not ideal for large files, but works for demo)
+      await AsyncStorage.setItem(key, data.toString('base64'));
+      log.debug('Saved recording data', {
+        deviceId,
+        recordingUuid,
+        size: data.length,
+      });
+      return key;
+    } catch (error) {
+      log.error('Failed to save recording data', error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * Load recording data
+   */
+  async loadRecordingData(localPath: string): Promise<Buffer> {
+    try {
+      const data = await AsyncStorage.getItem(localPath);
+      if (!data) {
+        throw new Error(`Recording not found: ${localPath}`);
+      }
+      return Buffer.from(data, 'base64');
+    } catch (error) {
+      log.error('Failed to load recording data', error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete recording data
+   */
+  async deleteRecordingData(localPath: string): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(localPath);
+      log.debug('Deleted recording data', { localPath });
+    } catch (error) {
+      log.error('Failed to delete recording data', error as Error);
+    }
+  }
+
+  /**
+   * Clear all SDK storage
+   */
+  async clearAll(): Promise<void> {
+    log.info('Clearing all SDK storage');
+
+    try {
+      const keys = await AsyncStorage.getAllKeys();
+      const botaKeys = keys.filter((k) => k.startsWith(STORAGE_PREFIX));
+      await AsyncStorage.multiRemove(botaKeys);
+
+      this.uploadQueue = [];
+      this.sdkState = { lastSyncTimes: {}, deviceInfo: {} };
+    } catch (error) {
+      log.error('Failed to clear storage', error as Error);
+    }
+  }
+
+  /**
+   * Clean up resources
+   */
+  destroy(): void {
+    this.uploadQueue = [];
+    this.sdkState = { lastSyncTimes: {}, deviceInfo: {} };
+    this.isInitialized = false;
+  }
+}
+
+/**
+ * Generate a unique task ID
+ */
+export function generateTaskId(): string {
+  return `task_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}

package/src/storage/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Storage module exports
+ */
+
+export { StorageManager, generateTaskId } from './StorageManager';

package/src/upload/S3Uploader.ts

@@ -0,0 +1,164 @@
+/**
+ * S3 Uploader - Handles uploading audio files to S3 using pre-signed URLs
+ */
+
+import { Buffer } from 'buffer';
+
+import { UploadError } from '../utils/errors';
+import { logger } from '../utils/logger';
+
+const log = logger.tag('S3Uploader');
+
+/**
+ * Upload progress callback
+ */
+export type UploadProgressCallback = (progress: number) => void;
+
+/**
+ * Upload options
+ */
+export interface UploadOptions {
+  /** Content type (default: audio/opus) */
+  contentType?: string;
+  /** Progress callback */
+  onProgress?: UploadProgressCallback;
+  /** Abort signal for cancellation */
+  abortSignal?: AbortSignal;
+}
+
+/**
+ * S3 Uploader class
+ */
+export class S3Uploader {
+  /**
+   * Upload a file to S3 using a pre-signed URL
+   */
+  async upload(
+    data: Buffer,
+    uploadUrl: string,
+    options: UploadOptions = {}
+  ): Promise<void> {
+    const {
+      contentType = 'audio/opus',
+      onProgress,
+      abortSignal,
+    } = options;
+
+    log.info('Starting S3 upload', {
+      size: data.length,
+      contentType,
+    });
+
+    try {
+      // For React Native, we use fetch with the PUT method
+      const response = await fetch(uploadUrl, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': contentType,
+          'Content-Length': data.length.toString(),
+        },
+        body: data,
+        signal: abortSignal,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => 'Unknown error');
+        log.error('S3 upload failed', undefined, {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText,
+        });
+
+        if (response.status === 403) {
+          throw UploadError.urlExpired('');
+        }
+
+        throw new UploadError(
+          `S3 upload failed: ${response.status} ${response.statusText}`,
+          'S3_UPLOAD_FAILED'
+        );
+      }
+
+      // Report completion
+      onProgress?.(1.0);
+
+      log.info('S3 upload completed', { size: data.length });
+    } catch (error) {
+      if (error instanceof UploadError) {
+        throw error;
+      }
+
+      const err = error as Error;
+
+      // Check for abort
+      if (err.name === 'AbortError') {
+        throw new UploadError('Upload was cancelled', 'UPLOAD_CANCELLED');
+      }
+
+      // Check for network errors
+      if (err.message?.includes('Network request failed')) {
+        throw UploadError.networkUnavailable();
+      }
+
+      throw new UploadError(
+        `Upload failed: ${err.message}`,
+        'UPLOAD_FAILED',
+        undefined,
+        err
+      );
+    }
+  }
+
+  /**
+   * Upload a file in chunks (for larger files)
+   * Note: This requires multipart upload support from the pre-signed URL
+   */
+  async uploadChunked(
+    data: Buffer,
+    uploadUrl: string,
+    options: UploadOptions = {}
+  ): Promise<void> {
+    // For now, delegate to simple upload
+    // In production, you'd implement S3 multipart upload here
+    return this.upload(data, uploadUrl, options);
+  }
+
+  /**
+   * Notify the backend that upload is complete
+   */
+  async notifyCompletion(
+    completeUrl: string,
+    recordingId: string,
+    uploadToken: string
+  ): Promise<void> {
+    log.debug('Notifying upload completion', { recordingId });
+
+    try {
+      const response = await fetch(completeUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${uploadToken}`,
+        },
+        body: JSON.stringify({ recording_id: recordingId }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => 'Unknown error');
+        throw new UploadError(
+          `Completion notification failed: ${response.status} - ${errorText}`,
+          'COMPLETION_FAILED'
+        );
+      }
+
+      log.info('Upload completion notified', { recordingId });
+    } catch (error) {
+      if (error instanceof UploadError) {
+        throw error;
+      }
+
+      const err = error as Error;
+      throw UploadError.completionFailed('', err);
+    }
+  }
+}