@switchlabs/verify-ai-react-native 0.1.0

package/src/storage/offlineQueue.ts

@@ -0,0 +1,200 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { VerificationRequest, VerificationResult, QueueItem } from '../types';
+import { VerifyAIClient } from '../client';
+
+const MANIFEST_KEY = '@verifyai/queue_manifest';
+const ITEM_PREFIX = '@verifyai/queue_item_';
+const LEGACY_KEY = '@verifyai/offline_queue';
+
+export class OfflineQueue {
+  private client: VerifyAIClient;
+  private processing = false;
+  private migrated = false;
+
+  constructor(client: VerifyAIClient) {
+    this.client = client;
+  }
+
+  /**
+   * Migrate from legacy single-key storage to per-item keys.
+   * Runs once per instance, no-ops if already migrated or no legacy data.
+   */
+  private async migrateIfNeeded(): Promise<void> {
+    if (this.migrated) return;
+    this.migrated = true;
+
+    const legacy = await AsyncStorage.getItem(LEGACY_KEY);
+    if (!legacy) return;
+
+    try {
+      const items: QueueItem[] = JSON.parse(legacy);
+      if (!Array.isArray(items) || items.length === 0) {
+        await AsyncStorage.removeItem(LEGACY_KEY);
+        return;
+      }
+
+      const ids: string[] = [];
+      const pairs: [string, string][] = [];
+      for (const item of items) {
+        ids.push(item.id);
+        pairs.push([`${ITEM_PREFIX}${item.id}`, JSON.stringify(item)]);
+      }
+
+      await AsyncStorage.multiSet([
+        [MANIFEST_KEY, JSON.stringify(ids)],
+        ...pairs,
+      ]);
+      await AsyncStorage.removeItem(LEGACY_KEY);
+    } catch {
+      // If migration fails, remove corrupt legacy data
+      await AsyncStorage.removeItem(LEGACY_KEY);
+    }
+  }
+
+  private async getManifest(): Promise<string[]> {
+    await this.migrateIfNeeded();
+    const raw = await AsyncStorage.getItem(MANIFEST_KEY);
+    return raw ? JSON.parse(raw) : [];
+  }
+
+  private async setManifest(ids: string[]): Promise<void> {
+    await AsyncStorage.setItem(MANIFEST_KEY, JSON.stringify(ids));
+  }
+
+  /**
+   * Add a verification request to the offline queue.
+   * Returns a temporary ID that can be used to track the item.
+   */
+  async enqueue(request: VerificationRequest): Promise<string> {
+    const item: QueueItem = {
+      id: `offline_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      request,
+      createdAt: Date.now(),
+      retryCount: 0,
+    };
+
+    const ids = await this.getManifest();
+    ids.push(item.id);
+
+    await AsyncStorage.setItem(`${ITEM_PREFIX}${item.id}`, JSON.stringify(item));
+    await this.setManifest(ids);
+    return item.id;
+  }
+
+  /**
+   * Get all items currently in the offline queue.
+   */
+  async getQueue(): Promise<QueueItem[]> {
+    const ids = await this.getManifest();
+    if (ids.length === 0) return [];
+
+    const keys = ids.map((id) => `${ITEM_PREFIX}${id}`);
+    const pairs = await AsyncStorage.multiGet(keys);
+
+    const items: QueueItem[] = [];
+    for (const [, value] of pairs) {
+      if (value) {
+        try {
+          items.push(JSON.parse(value));
+        } catch {
+          // Skip corrupt items
+        }
+      }
+    }
+    return items;
+  }
+
+  /**
+   * Get the number of items waiting in the queue.
+   */
+  async getQueueSize(): Promise<number> {
+    const ids = await this.getManifest();
+    return ids.length;
+  }
+
+  /**
+   * Remove an item from the queue by ID.
+   */
+  async remove(id: string): Promise<void> {
+    const ids = await this.getManifest();
+    const filtered = ids.filter((i) => i !== id);
+    await this.setManifest(filtered);
+    await AsyncStorage.removeItem(`${ITEM_PREFIX}${id}`);
+  }
+
+  /**
+   * Clear all items from the queue.
+   */
+  async clear(): Promise<void> {
+    const ids = await this.getManifest();
+    if (ids.length > 0) {
+      const keys = ids.map((id) => `${ITEM_PREFIX}${id}`);
+      await AsyncStorage.multiRemove([MANIFEST_KEY, ...keys]);
+    } else {
+      await AsyncStorage.removeItem(MANIFEST_KEY);
+    }
+  }
+
+  /**
+   * Process all queued items, sending them to the API.
+   * Returns results for successfully processed items.
+   *
+   * Call this when the device comes back online or on app foreground.
+   *
+   * @param onResult - Optional callback fired for each successful verification
+   * @param maxRetries - Maximum retry attempts before dropping an item (default: 3)
+   */
+  async processQueue(
+    onResult?: (queueId: string, result: VerificationResult) => void,
+    maxRetries = 3
+  ): Promise<{ processed: number; failed: number; remaining: number }> {
+    if (this.processing) {
+      const size = await this.getQueueSize();
+      return { processed: 0, failed: 0, remaining: size };
+    }
+
+    this.processing = true;
+    let processed = 0;
+    let failed = 0;
+    const remainingIds: string[] = [];
+
+    try {
+      const ids = await this.getManifest();
+
+      for (const id of ids) {
+        const raw = await AsyncStorage.getItem(`${ITEM_PREFIX}${id}`);
+        if (!raw) continue;
+
+        let item: QueueItem;
+        try {
+          item = JSON.parse(raw);
+        } catch {
+          // Remove corrupt item
+          await AsyncStorage.removeItem(`${ITEM_PREFIX}${id}`);
+          continue;
+        }
+
+        try {
+          const result = await this.client.verify(item.request);
+          processed++;
+          await AsyncStorage.removeItem(`${ITEM_PREFIX}${id}`);
+          onResult?.(item.id, result);
+        } catch {
+          item.retryCount++;
+          if (item.retryCount < maxRetries) {
+            await AsyncStorage.setItem(`${ITEM_PREFIX}${id}`, JSON.stringify(item));
+            remainingIds.push(id);
+          } else {
+            failed++;
+            await AsyncStorage.removeItem(`${ITEM_PREFIX}${id}`);
+          }
+        }
+      }
+
+      await this.setManifest(remainingIds);
+      return { processed, failed, remaining: remainingIds.length };
+    } finally {
+      this.processing = false;
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,66 @@
+export interface VerifyAIConfig {
+  apiKey: string;
+  baseUrl?: string;
+  timeout?: number;
+  offlineMode?: boolean;
+}
+
+export interface VerificationRequest {
+  image: string; // base64 encoded image data
+  policy: string;
+  metadata?: Record<string, unknown>;
+  provider?: 'openai' | 'anthropic' | 'gemini';
+}
+
+export interface VerificationResult {
+  id: string;
+  created_at: string;
+  status: 'success' | 'error';
+  is_compliant: boolean;
+  confidence: number;
+  policy: string;
+  violation_reasons: string[];
+  feedback: string;
+  metadata: Record<string, unknown>;
+  image_url: string | null;
+}
+
+export interface VerificationListResponse {
+  data: VerificationResult[];
+  has_more: boolean;
+  next_cursor: string | null;
+}
+
+export interface VerificationListParams {
+  limit?: number;
+  cursor?: string;
+  policy?: string;
+  status?: string;
+  is_compliant?: boolean;
+  start_date?: string;
+  end_date?: string;
+}
+
+export interface QueueItem {
+  id: string;
+  request: VerificationRequest;
+  createdAt: number;
+  retryCount: number;
+}
+
+export interface VerifyAIError {
+  error: string;
+  status: number;
+  current_usage?: number;
+  limit?: number;
+  upgrade_url?: string;
+}
+
+export type ScannerStatus = 'idle' | 'capturing' | 'processing' | 'success' | 'error';
+
+export interface ScannerOverlayConfig {
+  title?: string;
+  instructions?: string;
+  showGuideFrame?: boolean;
+  guideFrameAspectRatio?: number;
+}