@indraq-ota/react-native-sdk 0.1.0-mvp

package/README.md

@@ -0,0 +1,8 @@
+# @indraq-ota/react-native-sdk
+
+IndraQ OTA React Native SDK MVP.
+
+## Install
+
+```bash
+npm install @indraq-ota/react-native-sdk react-native-fs react-native-zip-archive

package/index.d.ts

@@ -0,0 +1,76 @@
+export type IndraqOtaPlatform = 'android' | 'ios';
+
+export type CheckForUpdateInput = {
+  serverUrl: string;
+  appSlug: string;
+  platform: IndraqOtaPlatform;
+  channel: string;
+  runtimeVersion: string;
+  currentLabel?: string;
+  appVersion?: string;
+  deviceId?: string;
+  apiKey?: string;
+  extra?: Record<string, unknown>;
+};
+
+export type OtaRelease = {
+  releaseId?: string;
+  id?: string;
+  label?: string;
+  appSlug?: string;
+  platform?: string;
+  channel?: string;
+  runtimeVersion?: string;
+  bundleUrl?: string;
+  bundleSha256?: string;
+  bundleHash?: string;
+  assetsUrl?: string;
+  assetsSha256?: string;
+  assetsHash?: string;
+  mandatory?: boolean;
+  rolloutPercentage?: number;
+  [key: string]: unknown;
+};
+
+export type CheckForUpdateResult = {
+  updateAvailable: boolean;
+  release?: OtaRelease | null;
+  [key: string]: unknown;
+};
+
+export type DownloadUpdateResult = {
+  success: boolean;
+  release: OtaRelease;
+  releaseDir: string;
+  bundlePath: string;
+  assetsZipPath?: string | null;
+  assetsDir?: string | null;
+  bundleSha256?: string | null;
+  assetsSha256?: string | null;
+};
+
+export type InstallUpdateResult = {
+  success: boolean;
+  currentManifestPath: string;
+  bundlePath: string;
+  release: OtaRelease;
+  note: string;
+};
+
+export type IndraqOTAApi = {
+  checkForUpdate(input: CheckForUpdateInput): Promise<CheckForUpdateResult>;
+  downloadUpdate(release: OtaRelease): Promise<DownloadUpdateResult>;
+  installUpdate(): Promise<InstallUpdateResult>;
+  getCurrentUpdate(): Promise<any | null>;
+  getPendingUpdate(): Promise<any | null>;
+  clearUpdate(): Promise<{ success: true }>;
+};
+
+declare const IndraqOTA: IndraqOTAApi;
+export default IndraqOTA;
+export const checkForUpdate: IndraqOTAApi['checkForUpdate'];
+export const downloadUpdate: IndraqOTAApi['downloadUpdate'];
+export const installUpdate: IndraqOTAApi['installUpdate'];
+export const getCurrentUpdate: IndraqOTAApi['getCurrentUpdate'];
+export const getPendingUpdate: IndraqOTAApi['getPendingUpdate'];
+export const clearUpdate: IndraqOTAApi['clearUpdate'];

package/index.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const { Platform, DevSettings } = require('react-native');
+const RNFS = require('react-native-fs');
+
+let ZipArchive = null;
+try {
+  ZipArchive = require('react-native-zip-archive');
+} catch (_) {
+  ZipArchive = null;
+}
+
+const OTA_ROOT = `${RNFS.DocumentDirectoryPath}/indraq-ota`;
+const RELEASES_DIR = `${OTA_ROOT}/releases`;
+const PENDING_MANIFEST = `${OTA_ROOT}/pending.json`;
+const CURRENT_MANIFEST = `${OTA_ROOT}/current.json`;
+
+function cleanBaseUrl(serverUrl) {
+  if (!serverUrl || typeof serverUrl !== 'string') {
+    throw new Error('serverUrl is required');
+  }
+  return serverUrl.replace(/\/+$/, '');
+}
+
+function pick(obj, keys) {
+  for (const key of keys) {
+    if (obj && obj[key]) return obj[key];
+  }
+  return null;
+}
+
+function safeSegment(value, fallback) {
+  return String(value || fallback || 'release')
+    .replace(/[^a-zA-Z0-9._-]/g, '_')
+    .slice(0, 120);
+}
+
+async function ensureDir(dir) {
+  const exists = await RNFS.exists(dir);
+  if (!exists) await RNFS.mkdir(dir);
+}
+
+async function writeJson(path, value) {
+  await ensureDir(OTA_ROOT);
+  await RNFS.writeFile(path, JSON.stringify(value, null, 2), 'utf8');
+}
+
+async function readJson(path) {
+  const exists = await RNFS.exists(path);
+  if (!exists) return null;
+  const raw = await RNFS.readFile(path, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function sha256(filePath) {
+  return RNFS.hash(filePath, 'sha256');
+}
+
+async function removeIfExists(path) {
+  const exists = await RNFS.exists(path);
+  if (exists) await RNFS.unlink(path);
+}
+
+async function downloadToFile(url, toFile, expectedSha256) {
+  if (!url) throw new Error('download url is missing');
+
+  await ensureDir(toFile.substring(0, toFile.lastIndexOf('/')));
+  await removeIfExists(toFile);
+
+  const result = await RNFS.downloadFile({
+    fromUrl: url,
+    toFile,
+    background: false,
+    discretionary: false,
+  }).promise;
+
+  if (!result || result.statusCode < 200 || result.statusCode >= 300) {
+    throw new Error(`Download failed with HTTP ${result ? result.statusCode : 'unknown'}`);
+  }
+
+  const actualSha = await sha256(toFile);
+  if (expectedSha256 && actualSha.toLowerCase() !== String(expectedSha256).toLowerCase()) {
+    await removeIfExists(toFile);
+    throw new Error(`SHA256 mismatch for ${url}. expected=${expectedSha256} actual=${actualSha}`);
+  }
+
+  return actualSha;
+}
+
+async function checkForUpdate(input) {
+  const serverUrl = cleanBaseUrl(input.serverUrl);
+  const body = {
+    appSlug: input.appSlug,
+    platform: input.platform || Platform.OS,
+    channel: input.channel,
+    runtimeVersion: input.runtimeVersion,
+    currentLabel: input.currentLabel,
+    appVersion: input.appVersion,
+    deviceId: input.deviceId,
+    ...(input.extra || {}),
+  };
+
+  const headers = {
+    'Content-Type': 'application/json',
+  };
+
+  if (input.apiKey) {
+    headers['x-ota-api-key'] = input.apiKey;
+    headers['x-api-key'] = input.apiKey;
+  }
+
+  const response = await fetch(`${serverUrl}/api/v1/updates/check`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  const text = await response.text();
+  let json = null;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch (_) {
+    json = null;
+  }
+
+  if (!response.ok) {
+    const msg = json?.message || json?.error || text || `Update check failed with HTTP ${response.status}`;
+    throw new Error(msg);
+  }
+
+  const data = json?.data || json;
+  return data || { updateAvailable: false, release: null };
+}
+
+async function downloadUpdate(release) {
+  if (!release || typeof release !== 'object') {
+    throw new Error('release is required');
+  }
+
+  const bundleUrl = pick(release, ['bundleUrl', 'bundleURL', 'bundleDownloadUrl']);
+  const assetsUrl = pick(release, ['assetsUrl', 'assetsURL', 'assetsZipUrl', 'assetsDownloadUrl']);
+  const bundleExpectedSha = pick(release, ['bundleSha256', 'bundleSHA256', 'bundleHash', 'hash']);
+  const assetsExpectedSha = pick(release, ['assetsSha256', 'assetsSHA256', 'assetsHash']);
+
+  if (!bundleUrl) {
+    throw new Error('release.bundleUrl is missing');
+  }
+
+  const releaseKey = safeSegment(release.label || release.releaseId || release.id, Date.now());
+  const releaseDir = `${RELEASES_DIR}/${releaseKey}`;
+  const bundlePath = `${releaseDir}/index.${Platform.OS}.bundle`;
+  const assetsZipPath = assetsUrl ? `${releaseDir}/assets.zip` : null;
+  const assetsDir = assetsUrl ? `${releaseDir}/assets` : null;
+
+  await ensureDir(OTA_ROOT);
+  await ensureDir(RELEASES_DIR);
+  await ensureDir(releaseDir);
+
+  const bundleActualSha = await downloadToFile(bundleUrl, bundlePath, bundleExpectedSha);
+
+  let assetsActualSha = null;
+  if (assetsUrl) {
+    assetsActualSha = await downloadToFile(assetsUrl, assetsZipPath, assetsExpectedSha);
+
+    if (ZipArchive && typeof ZipArchive.unzip === 'function') {
+      await ensureDir(assetsDir);
+      await ZipArchive.unzip(assetsZipPath, assetsDir);
+    }
+  }
+
+  const manifest = {
+    downloadedAt: new Date().toISOString(),
+    release,
+    releaseDir,
+    bundlePath,
+    assetsZipPath,
+    assetsDir,
+    bundleSha256: bundleActualSha,
+    assetsSha256: assetsActualSha,
+  };
+
+  await writeJson(PENDING_MANIFEST, manifest);
+
+  return {
+    success: true,
+    release,
+    releaseDir,
+    bundlePath,
+    assetsZipPath,
+    assetsDir,
+    bundleSha256: bundleActualSha,
+    assetsSha256: assetsActualSha,
+  };
+}
+
+async function installUpdate(options = {}) {
+  const pending = await readJson(PENDING_MANIFEST);
+  if (!pending || !pending.bundlePath) {
+    throw new Error('No pending OTA update found. Download update first.');
+  }
+
+  const exists = await RNFS.exists(pending.bundlePath);
+  if (!exists) {
+    throw new Error(`Pending bundle file not found: ${pending.bundlePath}`);
+  }
+
+  const currentManifest = {
+    ...pending,
+    installedAt: new Date().toISOString(),
+  };
+
+  await writeJson(CURRENT_MANIFEST, currentManifest);
+  await removeIfExists(PENDING_MANIFEST);
+
+  const shouldReload = options?.reload === true;
+
+  if (shouldReload && DevSettings && typeof DevSettings.reload === 'function') {
+    setTimeout(() => DevSettings.reload(), 300);
+  }
+
+  return {
+    success: true,
+    currentManifestPath: CURRENT_MANIFEST,
+    bundlePath: pending.bundlePath,
+    release: pending.release,
+    installedLabel: pending.release?.label || null,
+    note: 'Update marked as current. Native loader integration is required to boot from downloaded bundle.',
+  };
+}
+
+async function getCurrentUpdate() {
+  return readJson(CURRENT_MANIFEST);
+}
+
+async function getPendingUpdate() {
+  return readJson(PENDING_MANIFEST);
+}
+
+async function clearUpdate() {
+  await removeIfExists(PENDING_MANIFEST);
+  await removeIfExists(CURRENT_MANIFEST);
+  return { success: true };
+}
+
+const api = {
+  checkForUpdate,
+  downloadUpdate,
+  installUpdate,
+  getCurrentUpdate,
+  getPendingUpdate,
+  clearUpdate,
+};
+
+module.exports = api;
+module.exports.default = api;
+module.exports.checkForUpdate = checkForUpdate;
+module.exports.downloadUpdate = downloadUpdate;
+module.exports.installUpdate = installUpdate;
+module.exports.getCurrentUpdate = getCurrentUpdate;
+module.exports.getPendingUpdate = getPendingUpdate;
+module.exports.clearUpdate = clearUpdate;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@indraq-ota/react-native-sdk",
+  "version": "0.1.0-mvp",
+  "description": "IndraQ OTA React Native SDK MVP for checking, downloading and installing OTA JavaScript bundle updates.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "react-native": "index.js",
+  "license": "MIT",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "package.json",
+    "README.md"
+  ],
+  "keywords": [
+    "react-native",
+    "ota",
+    "over-the-air",
+    "updates",
+    "indraq"
+  ],
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-fs": "*",
+    "react-native-zip-archive": "*"
+  }
+}