@viettelpost/react-native-ota 0.1.0

package/src/OTAClient.ts

@@ -0,0 +1,151 @@
+import { Platform } from 'react-native';
+
+import {
+  downloadAndInstallBundle,
+  getCurrentBundleInfo,
+  getOTAMetadata,
+  type OTABundleInfo,
+  type OTAMetadata,
+  type OTAUpdatePayload,
+} from './NativeOTAUpdate';
+import { getConfig, resolveHeaders, type OTAConfig } from './config';
+
+export type OTACheckUpdateResponse = {
+  version: string;
+  bundleUrl: string;
+  fileName: string;
+  platform: 'android' | 'ios';
+  sha256: string;
+  signature: string;
+  assetsUrl?: string;
+  assetsSha256?: string;
+};
+
+export type OTAUpdateResult =
+  | { success: true; version: string; alreadyUpToDate?: boolean }
+  | { success: false; code: string; message: string };
+
+function buildCheckUpdateURL(
+  baseURL: string,
+  currentVersion: string,
+  checkUpdatePath = '/api/ota/check-update',
+): string {
+  const platform = Platform.OS === 'ios' ? 'ios' : 'android';
+  const normalizedBaseURL = baseURL.replace(/\/+$/, '');
+  const normalizedPath = checkUpdatePath.startsWith('/')
+    ? checkUpdatePath
+    : `/${checkUpdatePath}`;
+  return `${normalizedBaseURL}${normalizedPath}?platform=${platform}&currentVersion=${encodeURIComponent(currentVersion)}`;
+}
+
+async function fetchUpdateMetadata(
+  url: string,
+  headers: Record<string, string>,
+): Promise<OTACheckUpdateResponse | null> {
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json', ...headers },
+  });
+
+  if (response.status === 204) {
+    return null;
+  }
+  if (!response.ok) {
+    throw new Error(`OTA check-update failed: HTTP ${response.status}`);
+  }
+
+  const data = (await response.json()) as Record<string, unknown>;
+  const required = ['version', 'bundleUrl', 'fileName', 'platform', 'sha256', 'signature'];
+  for (const field of required) {
+    if (typeof data[field] !== 'string' || !(data[field] as string).trim()) {
+      throw new Error(`OTA check-update response missing required field: ${field}`);
+    }
+  }
+  return data as unknown as OTACheckUpdateResponse;
+}
+
+function toPayload(r: OTACheckUpdateResponse): OTAUpdatePayload {
+  return {
+    version: r.version,
+    bundleUrl: r.bundleUrl,
+    platform: r.platform,
+    fileName: r.fileName,
+    sha256: r.sha256,
+    signature: r.signature,
+    assetsUrl: r.assetsUrl,
+    assetsSha256: r.assetsSha256,
+  };
+}
+
+export async function checkAndInstallOTA(
+  otaBaseURL: string,
+  options: Pick<OTAConfig, 'headers' | 'checkUpdatePath'> = {},
+): Promise<OTAUpdateResult> {
+  try {
+    const metadata = await getOTAMetadata();
+    const currentVersion =
+      metadata.activeBundleVersion || metadata.embeddedBundleVersion;
+
+    const url = buildCheckUpdateURL(
+      otaBaseURL,
+      currentVersion,
+      options.checkUpdatePath,
+    );
+    const update = await fetchUpdateMetadata(
+      url,
+      await resolveHeaders(options.headers),
+    );
+
+    if (!update) {
+      return { success: true, version: currentVersion, alreadyUpToDate: true };
+    }
+
+    const expectedPlatform = Platform.OS === 'ios' ? 'ios' : 'android';
+    if (update.platform !== expectedPlatform) {
+      return {
+        success: false,
+        code: 'OTA_PLATFORM_MISMATCH',
+        message: `Server returned platform=${update.platform}, expected ${expectedPlatform}`,
+      };
+    }
+
+    if (metadata.activeBundleVersion === update.version) {
+      return { success: true, version: update.version, alreadyUpToDate: true };
+    }
+
+    const didInstall = await downloadAndInstallBundle(toPayload(update));
+    if (!didInstall) {
+      return {
+        success: false,
+        code: 'OTA_INSTALL_FAILED',
+        message: `Failed to install OTA update version ${update.version}`,
+      };
+    }
+    return { success: true, version: update.version };
+  } catch (error) {
+    return {
+      success: false,
+      code: 'OTA_SERVICE_ERROR',
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function sync(): Promise<OTAUpdateResult> {
+  const config = getConfig();
+  return checkAndInstallOTA(config.baseURL, {
+    headers: config.headers,
+    checkUpdatePath: config.checkUpdatePath,
+  });
+}
+
+export async function getCurrentOTAStatus(): Promise<{
+  metadata: OTAMetadata;
+  bundleInfo: OTABundleInfo;
+}> {
+  const [metadata, bundleInfo] = await Promise.all([
+    getOTAMetadata(),
+    getCurrentBundleInfo(),
+  ]);
+  return { metadata, bundleInfo };
+}

package/src/config.ts

@@ -0,0 +1,41 @@
+export type OTAHeaders =
+  | Record<string, string>
+  | (() => Record<string, string> | Promise<Record<string, string>>);
+
+export type OTAConfig = {
+  baseURL: string;
+  headers?: OTAHeaders;
+  checkUpdatePath?: string;
+  publicKey?: string;
+  policy?: {
+    autoInstall?: boolean;
+    restart?: 'manual' | 'immediate';
+  };
+};
+
+let currentConfig: OTAConfig | null = null;
+
+export function configure(config: OTAConfig): void {
+  if (!config.baseURL || !config.baseURL.trim()) {
+    throw new Error('OTA.configure requires a non-empty baseURL');
+  }
+  currentConfig = {
+    ...config,
+    baseURL: config.baseURL.replace(/\/+$/, ''),
+    checkUpdatePath: config.checkUpdatePath || '/api/ota/check-update',
+  };
+}
+
+export function getConfig(): OTAConfig {
+  if (!currentConfig) {
+    throw new Error('OTA is not configured. Call OTA.configure({ baseURL }) before syncing.');
+  }
+  return currentConfig;
+}
+
+export async function resolveHeaders(headers?: OTAHeaders): Promise<Record<string, string>> {
+  if (!headers) {
+    return {};
+  }
+  return typeof headers === 'function' ? headers() : headers;
+}

package/src/devtools.ts

@@ -0,0 +1,64 @@
+import {
+  cleanupOTAStorage,
+  downloadAndInstallBundle,
+  getCurrentBundleInfo,
+  getDownloadInfo,
+  getOTADiskUsage,
+  getOTADirectory,
+  getOTAMetadata,
+  markOTASuccess,
+  type OTAUpdatePayload,
+} from './NativeOTAUpdate';
+
+function warnIfNotDev() {
+  if (!__DEV__) {
+    console.warn('OTADevTools is intended only for manual OTA testing.');
+  }
+}
+
+export async function logOTAInfo() {
+  warnIfNotDev();
+  const [directory, metadata, bundleInfo] = await Promise.all([
+    getOTADirectory(),
+    getOTAMetadata(),
+    getCurrentBundleInfo(),
+  ]);
+  console.log('OTA directory:', directory);
+  console.log('OTA metadata:', metadata);
+  console.log('OTA bundle info:', bundleInfo);
+  return { directory, metadata, bundleInfo };
+}
+
+export async function confirmOTASuccess(): Promise<boolean> {
+  warnIfNotDev();
+  const didMarkSuccess = await markOTASuccess();
+  console.log('OTA success marked:', didMarkSuccess);
+  return didMarkSuccess;
+}
+
+export async function downloadAndInstallOTA(
+  update: OTAUpdatePayload,
+): Promise<boolean> {
+  warnIfNotDev();
+  const didInstall = await downloadAndInstallBundle(update);
+  const downloadInfo = await getDownloadInfo(update.version);
+  console.log('OTA downloaded install prepared:', didInstall, update.version);
+  console.log('OTA download info:', downloadInfo);
+  return didInstall;
+}
+
+export async function logOTADiskUsage() {
+  warnIfNotDev();
+  const diskUsage = await getOTADiskUsage();
+  console.log('OTA disk usage:', diskUsage);
+  return diskUsage;
+}
+
+export async function cleanupOTADevStorage(): Promise<boolean> {
+  warnIfNotDev();
+  const didCleanup = await cleanupOTAStorage();
+  const diskUsage = await getOTADiskUsage();
+  console.log('OTA cleanup completed:', didCleanup);
+  console.log('OTA disk usage after cleanup:', diskUsage);
+  return didCleanup;
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+import { configure, getConfig, type OTAConfig } from './config';
+import {
+  checkAndInstallOTA,
+  getCurrentOTAStatus,
+  sync,
+  type OTACheckUpdateResponse,
+  type OTAUpdateResult,
+} from './OTAClient';
+import {
+  cleanupOTAStorage,
+  copyBundleFromDocuments,
+  downloadAndInstallBundle,
+  getCurrentBundleInfo,
+  getDownloadInfo,
+  getOTADirectory,
+  getOTADiskUsage,
+  getOTAMetadata,
+  markOTASuccess,
+  prepareManualInstall,
+  resetOTAMetadata,
+  type OTABundleInfo,
+  type OTADiskUsage,
+  type OTADownloadInfo,
+  type OTAMetadata,
+  type OTAStatus,
+  type OTAUpdatePayload,
+} from './NativeOTAUpdate';
+
+export type {
+  OTAConfig,
+  OTACheckUpdateResponse,
+  OTAUpdateResult,
+  OTABundleInfo,
+  OTADiskUsage,
+  OTADownloadInfo,
+  OTAMetadata,
+  OTAStatus,
+  OTAUpdatePayload,
+};
+
+export {
+  checkAndInstallOTA,
+  cleanupOTAStorage,
+  configure,
+  copyBundleFromDocuments,
+  downloadAndInstallBundle,
+  getConfig,
+  getCurrentBundleInfo,
+  getCurrentOTAStatus,
+  getDownloadInfo,
+  getOTADirectory,
+  getOTADiskUsage,
+  getOTAMetadata,
+  markOTASuccess,
+  prepareManualInstall,
+  resetOTAMetadata,
+  sync,
+};
+
+export const OTA = {
+  configure,
+  sync,
+  checkAndInstall: checkAndInstallOTA,
+  markSuccess: markOTASuccess,
+  getMetadata: getOTAMetadata,
+  getCurrentBundleInfo,
+  getCurrentStatus: getCurrentOTAStatus,
+  cleanupStorage: cleanupOTAStorage,
+};

package/src/spec/NativeOTAUpdate.ts

@@ -0,0 +1,21 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  getMetadata(): Promise<string>;
+  resetMetadata(): Promise<boolean>;
+  getOTADirectory(): Promise<string>;
+  prepareManualInstall(bundleVersion: string): Promise<boolean>;
+  markSuccess(): Promise<boolean>;
+  copyBundleFromDocuments(
+    bundleVersion: string,
+    fileName: string,
+  ): Promise<boolean>;
+  getCurrentBundleInfo(): Promise<string>;
+  downloadAndInstallBundle(updateJson: string): Promise<boolean>;
+  getDownloadInfo(version: string): Promise<string>;
+  getOTADiskUsage(): Promise<string>;
+  cleanupOTAStorage(): Promise<boolean>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('OTAUpdate');