@switchlabs/verify-ai-react-native 0.1.0

package/lib/storage/offlineQueue.js

@@ -0,0 +1,179 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+const MANIFEST_KEY = '@verifyai/queue_manifest';
+const ITEM_PREFIX = '@verifyai/queue_item_';
+const LEGACY_KEY = '@verifyai/offline_queue';
+export class OfflineQueue {
+    constructor(client) {
+        this.processing = false;
+        this.migrated = false;
+        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.
+     */
+    async migrateIfNeeded() {
+        if (this.migrated)
+            return;
+        this.migrated = true;
+        const legacy = await AsyncStorage.getItem(LEGACY_KEY);
+        if (!legacy)
+            return;
+        try {
+            const items = JSON.parse(legacy);
+            if (!Array.isArray(items) || items.length === 0) {
+                await AsyncStorage.removeItem(LEGACY_KEY);
+                return;
+            }
+            const ids = [];
+            const pairs = [];
+            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);
+        }
+    }
+    async getManifest() {
+        await this.migrateIfNeeded();
+        const raw = await AsyncStorage.getItem(MANIFEST_KEY);
+        return raw ? JSON.parse(raw) : [];
+    }
+    async setManifest(ids) {
+        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) {
+        const item = {
+            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() {
+        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 = [];
+        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() {
+        const ids = await this.getManifest();
+        return ids.length;
+    }
+    /**
+     * Remove an item from the queue by ID.
+     */
+    async remove(id) {
+        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() {
+        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, maxRetries = 3) {
+        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 = [];
+        try {
+            const ids = await this.getManifest();
+            for (const id of ids) {
+                const raw = await AsyncStorage.getItem(`${ITEM_PREFIX}${id}`);
+                if (!raw)
+                    continue;
+                let item;
+                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/lib/types/index.d.ts

@@ -0,0 +1,58 @@
+export interface VerifyAIConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    offlineMode?: boolean;
+}
+export interface VerificationRequest {
+    image: string;
+    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;
+}

package/lib/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@switchlabs/verify-ai-react-native",
+  "version": "0.1.0",
+  "description": "React Native SDK for Verify AI - photo verification with AI vision processing",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "source": "./src/index.ts",
+  "react-native": "./src/index.ts",
+  "files": [
+    "src",
+    "lib"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "verify-ai",
+    "photo-verification",
+    "ai-vision",
+    "parking-compliance",
+    "damage-detection"
+  ],
+  "author": "Switch Labs",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0",
+    "expo-camera": ">=15.0.0",
+    "@react-native-async-storage/async-storage": ">=1.19.0"
+  },
+  "peerDependenciesMeta": {
+    "expo-camera": {
+      "optional": true
+    },
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@react-native-async-storage/async-storage": "^2.1.0",
+    "@types/react": "^18.2.0",
+    "expo-camera": "^16.0.0",
+    "react": "^18.2.0",
+    "react-native": "^0.76.0",
+    "typescript": "^5.5.0"
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,158 @@
+import type {
+  VerifyAIConfig,
+  VerificationRequest,
+  VerificationResult,
+  VerificationListResponse,
+  VerificationListParams,
+  VerifyAIError,
+} from '../types';
+
+const DEFAULT_BASE_URL = 'https://verify.switchlabs.dev/api/v1';
+const DEFAULT_TIMEOUT = 30000;
+
+export class VerifyAIClient {
+  private apiKey: string;
+  private baseUrl: string;
+  private timeout: number;
+
+  constructor(config: VerifyAIConfig) {
+    if (!config.apiKey) {
+      throw new Error('VerifyAI: apiKey is required');
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, '');
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+
+  private async request<T>(
+    path: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        signal: controller.signal,
+        headers: {
+          'X-API-Key': this.apiKey,
+          ...options.headers,
+        },
+      });
+
+      const body = await response.json();
+
+      if (!response.ok) {
+        const error = body as VerifyAIError;
+        throw new VerifyAIRequestError(
+          error.error || `Request failed with status ${response.status}`,
+          response.status,
+          error
+        );
+      }
+
+      return body as T;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /**
+   * Submit a photo for AI verification.
+   *
+   * @param request - The verification request with base64 image and policy
+   * @returns The verification result with compliance status and feedback
+   *
+   * @example
+   * ```typescript
+   * const result = await client.verify({
+   *   image: base64ImageData,
+   *   policy: 'scooter_parking',
+   *   metadata: { device_id: 'dev_123', gps: { lat: 37.77, lng: -122.42 } },
+   * });
+   *
+   * if (result.is_compliant) {
+   *   console.log('Parking approved!');
+   * } else {
+   *   console.log('Issues:', result.violation_reasons);
+   *   console.log('Feedback:', result.feedback);
+   * }
+   * ```
+   */
+  async verify(request: VerificationRequest): Promise<VerificationResult> {
+    return this.request<VerificationResult>('/verify', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    });
+  }
+
+  /**
+   * List past verifications with optional filters.
+   *
+   * @param params - Pagination and filter parameters
+   * @returns Paginated list of verification results
+   *
+   * @example
+   * ```typescript
+   * const { data, has_more, next_cursor } = await client.listVerifications({
+   *   limit: 20,
+   *   policy: 'scooter_parking',
+   *   is_compliant: false,
+   * });
+   * ```
+   */
+  async listVerifications(
+    params: VerificationListParams = {}
+  ): Promise<VerificationListResponse> {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set('limit', String(params.limit));
+    if (params.cursor) searchParams.set('cursor', params.cursor);
+    if (params.policy) searchParams.set('policy', params.policy);
+    if (params.status) searchParams.set('status', params.status);
+    if (params.is_compliant !== undefined)
+      searchParams.set('is_compliant', String(params.is_compliant));
+    if (params.start_date) searchParams.set('start_date', params.start_date);
+    if (params.end_date) searchParams.set('end_date', params.end_date);
+
+    const qs = searchParams.toString();
+    return this.request<VerificationListResponse>(
+      `/verifications${qs ? `?${qs}` : ''}`
+    );
+  }
+
+  /**
+   * Get a single verification by ID.
+   *
+   * @param id - The verification ID (e.g., "ver_8x92m4k9")
+   * @returns The full verification result with a fresh signed image URL
+   */
+  async getVerification(id: string): Promise<VerificationResult> {
+    return this.request<VerificationResult>(`/verifications/${id}`);
+  }
+}
+
+export class VerifyAIRequestError extends Error {
+  status: number;
+  body: VerifyAIError;
+
+  constructor(message: string, status: number, body: VerifyAIError) {
+    super(message);
+    this.name = 'VerifyAIRequestError';
+    this.status = status;
+    this.body = body;
+  }
+
+  get isRateLimited(): boolean {
+    return this.status === 429;
+  }
+
+  get isUnauthorized(): boolean {
+    return this.status === 401;
+  }
+
+  get upgradeUrl(): string | undefined {
+    return this.body.upgrade_url;
+  }
+}