@vanikya/ota-react-native 0.1.0

package/src/hooks/useOTAUpdate.ts

@@ -0,0 +1,344 @@
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { AppState, AppStateStatus, NativeModules, Platform } from 'react-native';
+import { OTAApiClient, ReleaseInfo, getDeviceInfo } from '../utils/api';
+import { UpdateStorage, StoredUpdate } from '../utils/storage';
+import { verifyBundle, VerificationResult } from '../utils/verification';
+
+const OTAUpdateNative = NativeModules.OTAUpdate;
+
+export interface OTAUpdateConfig {
+  serverUrl: string;
+  appSlug: string;
+  channel?: string;
+  appVersion: string;
+  publicKey?: string;
+  checkOnMount?: boolean;
+  checkOnForeground?: boolean;
+}
+
+export interface UpdateInfo {
+  version: string;
+  releaseId: string;
+  bundleSize: number;
+  isMandatory: boolean;
+  releaseNotes: string | null;
+}
+
+export interface DownloadProgress {
+  downloadedBytes: number;
+  totalBytes: number;
+  percentage: number;
+}
+
+export type UpdateStatus =
+  | 'idle'
+  | 'checking'
+  | 'available'
+  | 'downloading'
+  | 'verifying'
+  | 'ready'
+  | 'applying'
+  | 'error'
+  | 'up-to-date';
+
+export interface UseOTAUpdateResult {
+  status: UpdateStatus;
+  updateInfo: UpdateInfo | null;
+  downloadProgress: DownloadProgress | null;
+  error: Error | null;
+  currentVersion: string | null;
+  checkForUpdate: () => Promise<UpdateInfo | null>;
+  downloadUpdate: () => Promise<void>;
+  applyUpdate: (restartApp?: boolean) => Promise<void>;
+  clearPendingUpdate: () => Promise<void>;
+}
+
+// Generate or get device ID
+async function getDeviceId(): Promise<string> {
+  // Try to get from native module or AsyncStorage
+  // For simplicity, we generate a random one and ideally persist it
+  // In production, use a proper device ID solution
+  const id = `device_${Math.random().toString(36).substring(2, 15)}`;
+  return id;
+}
+
+export function useOTAUpdate(config: OTAUpdateConfig): UseOTAUpdateResult {
+  const {
+    serverUrl,
+    appSlug,
+    channel = 'production',
+    appVersion,
+    publicKey,
+    checkOnMount = true,
+    checkOnForeground = true,
+  } = config;
+
+  const [status, setStatus] = useState<UpdateStatus>('idle');
+  const [updateInfo, setUpdateInfo] = useState<UpdateInfo | null>(null);
+  const [downloadProgress, setDownloadProgress] = useState<DownloadProgress | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [currentVersion, setCurrentVersion] = useState<string | null>(null);
+
+  const apiClient = useRef(new OTAApiClient(serverUrl));
+  const storage = useRef(new UpdateStorage());
+  const deviceIdRef = useRef<string | null>(null);
+  const releaseRef = useRef<ReleaseInfo | null>(null);
+
+  // Load current version on mount
+  useEffect(() => {
+    const loadCurrentVersion = async () => {
+      const metadata = await storage.current.getMetadata();
+      if (metadata) {
+        setCurrentVersion(metadata.version);
+      }
+    };
+    loadCurrentVersion();
+  }, []);
+
+  // Get device ID
+  const getDeviceIdCached = useCallback(async () => {
+    if (!deviceIdRef.current) {
+      deviceIdRef.current = await getDeviceId();
+    }
+    return deviceIdRef.current;
+  }, []);
+
+  // Check for updates
+  const checkForUpdate = useCallback(async (): Promise<UpdateInfo | null> => {
+    try {
+      setStatus('checking');
+      setError(null);
+
+      const deviceId = await getDeviceIdCached();
+      const currentMetadata = await storage.current.getMetadata();
+
+      const response = await apiClient.current.checkUpdate({
+        appSlug,
+        channel,
+        platform: Platform.OS as 'ios' | 'android',
+        currentVersion: currentMetadata?.version || null,
+        appVersion,
+        deviceId,
+      });
+
+      if (!response.updateAvailable || !response.release) {
+        setStatus('up-to-date');
+        return null;
+      }
+
+      releaseRef.current = response.release;
+
+      const info: UpdateInfo = {
+        version: response.release.version,
+        releaseId: response.release.id,
+        bundleSize: response.release.bundleSize,
+        isMandatory: response.release.isMandatory,
+        releaseNotes: response.release.releaseNotes,
+      };
+
+      setUpdateInfo(info);
+      setStatus('available');
+
+      return info;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setError(error);
+      setStatus('error');
+      return null;
+    }
+  }, [appSlug, channel, appVersion, getDeviceIdCached]);
+
+  // Download update
+  const downloadUpdate = useCallback(async (): Promise<void> => {
+    if (!releaseRef.current) {
+      throw new Error('No update available to download');
+    }
+
+    const release = releaseRef.current;
+    const deviceId = await getDeviceIdCached();
+
+    try {
+      setStatus('downloading');
+      setDownloadProgress({ downloadedBytes: 0, totalBytes: release.bundleSize, percentage: 0 });
+
+      // Report download start
+      apiClient.current.reportEvent({
+        appSlug,
+        releaseId: release.id,
+        deviceId,
+        eventType: 'download',
+        appVersion,
+        deviceInfo: getDeviceInfo(),
+      });
+
+      // Download bundle
+      const bundleData = await apiClient.current.downloadBundle(release.bundleUrl);
+
+      setDownloadProgress({
+        downloadedBytes: bundleData.byteLength,
+        totalBytes: release.bundleSize,
+        percentage: 100,
+      });
+
+      // Verify bundle
+      setStatus('verifying');
+
+      const verification = await verifyBundle(
+        bundleData,
+        release.bundleHash,
+        release.bundleSignature,
+        publicKey || null
+      );
+
+      if (!verification.valid) {
+        throw new Error(verification.error || 'Bundle verification failed');
+      }
+
+      // Save bundle
+      const bundlePath = await storage.current.saveBundle(release.id, bundleData);
+
+      // Save metadata
+      await storage.current.saveMetadata({
+        releaseId: release.id,
+        version: release.version,
+        bundlePath,
+        bundleHash: release.bundleHash,
+        downloadedAt: Date.now(),
+      });
+
+      setStatus('ready');
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+
+      // Report failure
+      apiClient.current.reportEvent({
+        appSlug,
+        releaseId: release.id,
+        deviceId,
+        eventType: 'failure',
+        errorMessage: error.message,
+        appVersion,
+        deviceInfo: getDeviceInfo(),
+      });
+
+      setError(error);
+      setStatus('error');
+      throw error;
+    }
+  }, [appSlug, appVersion, publicKey, getDeviceIdCached]);
+
+  // Apply update
+  const applyUpdate = useCallback(async (restartApp: boolean = true): Promise<void> => {
+    const metadata = await storage.current.getMetadata();
+
+    if (!metadata) {
+      throw new Error('No update available to apply');
+    }
+
+    const deviceId = await getDeviceIdCached();
+
+    try {
+      setStatus('applying');
+
+      // Report apply
+      apiClient.current.reportEvent({
+        appSlug,
+        releaseId: metadata.releaseId,
+        deviceId,
+        eventType: 'apply',
+        appVersion,
+        deviceInfo: getDeviceInfo(),
+      });
+
+      // Apply bundle using native module
+      if (OTAUpdateNative?.applyBundle) {
+        await OTAUpdateNative.applyBundle(metadata.bundlePath, restartApp);
+      } else if (restartApp) {
+        // If no native module, we need to restart manually
+        // The bundle will be loaded on next app start
+        if (__DEV__) {
+          console.log('[OTAUpdate] Update ready. Restart the app to apply.');
+        }
+      }
+
+      // Report success (this might not run if app restarts)
+      apiClient.current.reportEvent({
+        appSlug,
+        releaseId: metadata.releaseId,
+        deviceId,
+        eventType: 'success',
+        appVersion,
+        deviceInfo: getDeviceInfo(),
+      });
+
+      setCurrentVersion(metadata.version);
+      setStatus('idle');
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+
+      apiClient.current.reportEvent({
+        appSlug,
+        releaseId: metadata.releaseId,
+        deviceId,
+        eventType: 'failure',
+        errorMessage: error.message,
+        appVersion,
+        deviceInfo: getDeviceInfo(),
+      });
+
+      setError(error);
+      setStatus('error');
+      throw error;
+    }
+  }, [appSlug, appVersion, getDeviceIdCached]);
+
+  // Clear pending update
+  const clearPendingUpdate = useCallback(async (): Promise<void> => {
+    const metadata = await storage.current.getMetadata();
+
+    if (metadata) {
+      await storage.current.deleteBundle(metadata.releaseId);
+      await storage.current.clearMetadata();
+    }
+
+    setUpdateInfo(null);
+    releaseRef.current = null;
+    setStatus('idle');
+  }, []);
+
+  // Check on mount
+  useEffect(() => {
+    if (checkOnMount) {
+      checkForUpdate();
+    }
+  }, [checkOnMount, checkForUpdate]);
+
+  // Check on foreground
+  useEffect(() => {
+    if (!checkOnForeground) return;
+
+    const handleAppStateChange = (nextAppState: AppStateStatus) => {
+      if (nextAppState === 'active' && status === 'idle') {
+        checkForUpdate();
+      }
+    };
+
+    const subscription = AppState.addEventListener('change', handleAppStateChange);
+
+    return () => {
+      subscription.remove();
+    };
+  }, [checkOnForeground, checkForUpdate, status]);
+
+  return {
+    status,
+    updateInfo,
+    downloadProgress,
+    error,
+    currentVersion,
+    checkForUpdate,
+    downloadUpdate,
+    applyUpdate,
+    clearPendingUpdate,
+  };
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+// Main exports
+export { OTAProvider, useOTA, withOTA, UpdateBanner } from './OTAProvider';
+export type { OTAProviderProps, UpdateBannerProps } from './OTAProvider';
+
+// Hook export
+export { useOTAUpdate } from './hooks/useOTAUpdate';
+export type {
+  OTAUpdateConfig,
+  UpdateInfo,
+  DownloadProgress,
+  UpdateStatus,
+  UseOTAUpdateResult,
+} from './hooks/useOTAUpdate';
+
+// Utilities
+export { OTAApiClient, getDeviceInfo } from './utils/api';
+export type {
+  CheckUpdateRequest,
+  CheckUpdateResponse,
+  ReleaseInfo,
+  ReportEventRequest,
+} from './utils/api';
+
+export { UpdateStorage, getStorageAdapter } from './utils/storage';
+export type { StoredUpdate, StorageAdapter } from './utils/storage';
+
+export {
+  calculateHash,
+  verifyBundleHash,
+  verifySignature,
+  verifyBundle,
+} from './utils/verification';
+export type { VerificationResult } from './utils/verification';
+
+// Version info
+export const VERSION = '0.1.0';

package/src/utils/api.ts

@@ -0,0 +1,99 @@
+import { Platform } from 'react-native';
+
+export interface CheckUpdateRequest {
+  appSlug: string;
+  channel: string;
+  platform: 'ios' | 'android';
+  currentVersion: string | null;
+  appVersion: string;
+  deviceId: string;
+}
+
+export interface ReleaseInfo {
+  id: string;
+  version: string;
+  bundleUrl: string;
+  bundleHash: string;
+  bundleSignature: string | null;
+  bundleSize: number;
+  isMandatory: boolean;
+  releaseNotes: string | null;
+}
+
+export interface CheckUpdateResponse {
+  updateAvailable: boolean;
+  release?: ReleaseInfo;
+}
+
+export interface ReportEventRequest {
+  appSlug: string;
+  releaseId: string | null;
+  deviceId: string;
+  eventType: 'download' | 'apply' | 'success' | 'failure' | 'rollback';
+  errorMessage?: string;
+  appVersion?: string;
+  deviceInfo?: {
+    os: string;
+    osVersion: string;
+    [key: string]: unknown;
+  };
+}
+
+export class OTAApiClient {
+  private serverUrl: string;
+
+  constructor(serverUrl: string) {
+    this.serverUrl = serverUrl.replace(/\/$/, ''); // Remove trailing slash
+  }
+
+  async checkUpdate(request: CheckUpdateRequest): Promise<CheckUpdateResponse> {
+    const response = await fetch(`${this.serverUrl}/api/v1/check-update`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(request),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+      throw new Error((error as { error: string }).error || `HTTP ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  async reportEvent(request: ReportEventRequest): Promise<void> {
+    try {
+      await fetch(`${this.serverUrl}/api/v1/report-event`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(request),
+      });
+    } catch (error) {
+      // Silently fail analytics - don't block the app
+      if (__DEV__) {
+        console.warn('[OTAUpdate] Failed to report event:', error);
+      }
+    }
+  }
+
+  async downloadBundle(bundleUrl: string): Promise<ArrayBuffer> {
+    const response = await fetch(bundleUrl);
+
+    if (!response.ok) {
+      throw new Error(`Failed to download bundle: HTTP ${response.status}`);
+    }
+
+    return response.arrayBuffer();
+  }
+}
+
+export function getDeviceInfo(): { os: string; osVersion: string } {
+  return {
+    os: Platform.OS,
+    osVersion: Platform.Version.toString(),
+  };
+}