@hot-updater/react-native 0.28.0 → 0.29.0

package/src/native.ts

@@ -1,4 +1,9 @@
-import type { UpdateStatus } from "@hot-updater/core";
+import {
+  INVALID_COHORT_ERROR_MESSAGE,
+  isValidCohort,
+  normalizeCohortValue,
+  type UpdateStatus,
+} from "@hot-updater/core";
 import { NativeEventEmitter, Platform } from "react-native";
 import { HotUpdaterErrorCode, isHotUpdaterError } from "./error";
 import HotUpdaterNative, {
@@ -8,6 +13,30 @@ import HotUpdaterNative, {
 export { HotUpdaterErrorCode, isHotUpdaterError };
 
 const NIL_UUID = "00000000-0000-0000-0000-000000000000";
+const normalizeAndValidateCohort = (cohort: string): string => {
+  const normalized = normalizeCohortValue(cohort);
+  if (!isValidCohort(normalized)) {
+    throw new Error(INVALID_COHORT_ERROR_MESSAGE);
+  }
+  return normalized;
+};
+
+export interface ManifestAsset {
+  fileHash: string;
+}
+
+export interface Manifest {
+  bundleId: string;
+  assets: Record<string, ManifestAsset>;
+}
+
+type ActiveBundleSnapshotCacheValues = {
+  bundleId?: string;
+  manifest?: Manifest;
+  baseURL?: string | null;
+};
+
+type ActiveBundleSnapshotCacheKey = keyof ActiveBundleSnapshotCacheValues;
 
 /**
  * Built-in reload behaviors used by `HotUpdater.reload()`.
@@ -34,17 +63,16 @@ export type CustomReloadHandler = () => void | Promise<void>;
  */
 export type ReloadBehaviorSetting = ReloadBehavior | "custom";
 
-declare const __HOT_UPDATER_BUNDLE_ID: string | undefined;
-
-export const HotUpdaterConstants = {
-  HOT_UPDATER_BUNDLE_ID: __HOT_UPDATER_BUNDLE_ID || NIL_UUID,
-};
-
 class HotUpdaterSessionState {
   private readonly defaultChannel: string;
   private currentChannel: string;
+  private cachedCohort: string | undefined;
   private readonly inflightUpdates = new Map<string, Promise<boolean>>();
   private lastInstalledBundleId: string | null = null;
+  private readonly activeBundleSnapshotCache = new Map<
+    ActiveBundleSnapshotCacheKey,
+    ActiveBundleSnapshotCacheValues[ActiveBundleSnapshotCacheKey]
+  >();
 
   constructor() {
     const constants = HotUpdaterNative.getConstants();
@@ -85,12 +113,66 @@ class HotUpdaterSessionState {
     if (channel) {
       this.currentChannel = channel;
     }
+    this.clearActiveBundleSnapshotCache();
   }
 
   resetChannelState() {
     this.currentChannel = this.defaultChannel;
     this.lastInstalledBundleId = null;
     this.inflightUpdates.clear();
+    this.clearActiveBundleSnapshotCache();
+  }
+
+  getCachedBundleId(): string | undefined {
+    return this.getActiveBundleSnapshotValue("bundleId");
+  }
+
+  cacheBundleId(bundleId: string) {
+    this.setActiveBundleSnapshotValue("bundleId", bundleId);
+  }
+
+  getCachedManifest(): Manifest | undefined {
+    const manifest = this.getActiveBundleSnapshotValue("manifest");
+    return manifest ? cloneManifest(manifest) : undefined;
+  }
+
+  cacheManifest(manifest: Manifest) {
+    this.setActiveBundleSnapshotValue("manifest", cloneManifest(manifest));
+  }
+
+  getCachedBaseURL(): string | null | undefined {
+    return this.getActiveBundleSnapshotValue("baseURL");
+  }
+
+  cacheBaseURL(baseURL: string | null) {
+    this.setActiveBundleSnapshotValue("baseURL", baseURL);
+  }
+
+  getCachedCohort(): string | undefined {
+    return this.cachedCohort;
+  }
+
+  cacheCohort(cohort: string) {
+    this.cachedCohort = cohort;
+  }
+
+  private clearActiveBundleSnapshotCache() {
+    this.activeBundleSnapshotCache.clear();
+  }
+
+  private getActiveBundleSnapshotValue<K extends ActiveBundleSnapshotCacheKey>(
+    key: K,
+  ): ActiveBundleSnapshotCacheValues[K] | undefined {
+    return this.activeBundleSnapshotCache.get(key) as
+      | ActiveBundleSnapshotCacheValues[K]
+      | undefined;
+  }
+
+  private setActiveBundleSnapshotValue<K extends ActiveBundleSnapshotCacheKey>(
+    key: K,
+    value: ActiveBundleSnapshotCacheValues[K],
+  ) {
+    this.activeBundleSnapshotCache.set(key, value);
   }
 }
 
@@ -98,6 +180,16 @@ const sessionState = new HotUpdaterSessionState();
 let reloadBehavior: ReloadBehaviorSetting = "processRestart";
 let customReloadHandler: CustomReloadHandler | null = null;
 
+const cloneManifest = (manifest: Manifest): Manifest => ({
+  bundleId: manifest.bundleId,
+  assets: Object.fromEntries(
+    Object.entries(manifest.assets).map(([key, asset]) => [
+      key,
+      { fileHash: asset.fileHash },
+    ]),
+  ),
+});
+
 const getReloadProcess = (): (() => Promise<void>) | null => {
   const nativeModule = HotUpdaterNative as typeof HotUpdaterNative & {
     reloadProcess?: () => Promise<void>;
@@ -318,13 +410,72 @@ export const getMinBundleId = (): string => {
 /**
  * Fetches the current bundle version id.
  *
- * @async
- * @returns {string} Resolves with the current version id or null if not available.
+ * JS falls back to MIN_BUNDLE_ID only after native confirms there is no active
+ * downloaded bundle. When the native module does not expose `getBundleId()`,
+ * treat it as a JS/native SDK mismatch instead of silently reporting the
+ * built-in bundle.
+ *
+ * @returns {string} Resolves with the current version id.
  */
 export const getBundleId = (): string => {
-  return HotUpdaterConstants.HOT_UPDATER_BUNDLE_ID === NIL_UUID
-    ? getMinBundleId()
-    : HotUpdaterConstants.HOT_UPDATER_BUNDLE_ID;
+  const cachedBundleId = sessionState.getCachedBundleId();
+  if (cachedBundleId !== undefined) {
+    return cachedBundleId;
+  }
+
+  const nativeModule = HotUpdaterNative as typeof HotUpdaterNative & {
+    getBundleId?: () => string | null;
+  };
+
+  if (typeof nativeModule.getBundleId !== "function") {
+    throw new Error(
+      "[HotUpdater] Native module is missing 'getBundleId()'. This JS bundle requires a newer native @hot-updater/react-native SDK. Rebuild and release a new app version before delivering this OTA update.",
+    );
+  }
+
+  const bundleId = nativeModule.getBundleId();
+
+  const resolvedBundleId =
+    !bundleId || bundleId === NIL_UUID ? getMinBundleId() : bundleId;
+
+  sessionState.cacheBundleId(resolvedBundleId);
+  return resolvedBundleId;
+};
+
+/**
+ * Fetches the current manifest for the active bundle.
+ *
+ * Returns a normalized manifest with empty assets when manifest.json is missing
+ * or invalid.
+ */
+export const getManifest = (): Manifest => {
+  const cachedManifest = sessionState.getCachedManifest();
+  if (cachedManifest !== undefined) {
+    return cachedManifest;
+  }
+
+  const nativeModule = HotUpdaterNative as typeof HotUpdaterNative & {
+    getManifest?: () => Record<string, unknown> | string;
+  };
+  const manifest = nativeModule.getManifest?.();
+
+  let normalizedManifest: Manifest;
+
+  if (!manifest) {
+    normalizedManifest = createEmptyManifest();
+  } else if (typeof manifest === "string") {
+    try {
+      normalizedManifest = normalizeManifest(JSON.parse(manifest));
+    } catch {
+      normalizedManifest = createEmptyManifest();
+    }
+  } else {
+    normalizedManifest = normalizeManifest(manifest);
+  }
+
+  sessionState.cacheBundleId(normalizedManifest.bundleId);
+  sessionState.cacheManifest(normalizedManifest);
+  return cloneManifest(normalizedManifest);
 };
 
 /**
@@ -383,14 +534,16 @@ export type NotifyAppReadyResult = {
  * const result = HotUpdater.notifyAppReady();
  *
  * if (result.status === "RECOVERED") {
- *     // Send ROLLBACK analytics event
- *     analytics.track('bundle_rollback', { crashedBundleId: result.crashedBundleId });
+ *   // Send ROLLBACK analytics event
+ *   analytics.track("bundle_rollback", {
+ *     crashedBundleId: result.crashedBundleId,
+ *   });
  * }
  * ```
  */
 export const notifyAppReady = (): NotifyAppReadyResult => {
   const result = HotUpdaterNative.notifyAppReady();
-  // Oldarch returns JSON string, newarch returns array
+  // Older Android old-arch implementations returned JSON strings.
   if (typeof result === "string") {
     try {
       return normalizeNotifyAppReadyResult(JSON.parse(result));
@@ -414,6 +567,65 @@ const normalizeNotifyAppReadyResult = (
   return { status: "STABLE" };
 };
 
+const createEmptyManifest = (): Manifest => ({
+  bundleId: getBundleId(),
+  assets: {},
+});
+
+const normalizeManifest = (value: unknown): Manifest => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return createEmptyManifest();
+  }
+
+  const bundleIdValue = (value as { bundleId?: unknown }).bundleId;
+  const bundleId =
+    typeof bundleIdValue === "string" && bundleIdValue.trim()
+      ? bundleIdValue.trim()
+      : getBundleId();
+
+  return {
+    bundleId,
+    assets: normalizeManifestAssets((value as { assets?: unknown }).assets),
+  };
+};
+
+const normalizeManifestAssets = (value: unknown): Manifest["assets"] => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+
+  return Object.fromEntries(
+    Object.entries(value).flatMap(([key, entry]) => {
+      const trimmedKey = key.trim();
+
+      if (!trimmedKey) {
+        return [];
+      }
+
+      if (typeof entry === "string") {
+        const fileHash = entry.trim();
+
+        if (!fileHash) {
+          return [];
+        }
+
+        return [[trimmedKey, { fileHash }] as const];
+      }
+
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        return [];
+      }
+
+      const { fileHash } = entry as { fileHash?: unknown };
+      if (typeof fileHash !== "string" || !fileHash.trim()) {
+        return [];
+      }
+
+      return [[trimmedKey, { fileHash: fileHash.trim() }] as const];
+    }),
+  );
+};
+
 /**
  * Gets the list of bundle IDs that have been marked as crashed.
  * These bundles will be rejected if attempted to install again.
@@ -422,7 +634,7 @@ const normalizeNotifyAppReadyResult = (
  */
 export const getCrashHistory = (): string[] => {
   const result = HotUpdaterNative.getCrashHistory();
-  // Oldarch returns JSON string, newarch returns array
+  // Older Android old-arch implementations returned JSON strings.
   if (typeof result === "string") {
     try {
       return JSON.parse(result);
@@ -451,11 +663,15 @@ export const clearCrashHistory = (): boolean => {
  * @returns {string | null} Base URL string (e.g., "file:///data/.../bundle-store/abc123") or null if not available
  */
 export const getBaseURL = (): string | null => {
-  const result = HotUpdaterNative.getBaseURL();
-  if (typeof result === "string" && result !== "") {
-    return result;
+  const cachedBaseURL = sessionState.getCachedBaseURL();
+  if (cachedBaseURL !== undefined) {
+    return cachedBaseURL;
   }
-  return null;
+
+  const result = HotUpdaterNative.getBaseURL();
+  const baseURL = typeof result === "string" && result !== "" ? result : null;
+  sessionState.cacheBaseURL(baseURL);
+  return baseURL;
 };
 
 /**
@@ -472,3 +688,32 @@ export const resetChannel = async (): Promise<boolean> => {
   }
   return ok;
 };
+
+/**
+ * Sets the persisted cohort used for update checks.
+ *
+ * HotUpdater only derives a device-based cohort when nothing has been stored
+ * yet. If you need to restore that initial value later, read it with
+ * `getCohort()` before calling `setCohort()`, then store it yourself.
+ */
+export const setCohort = (cohort: string): void => {
+  const normalized = normalizeAndValidateCohort(cohort);
+  HotUpdaterNative.setCohort(normalized);
+  sessionState.cacheCohort(normalized);
+};
+
+/**
+ * Gets the persisted cohort used for rollout calculations.
+ * If none has been stored yet, native derives the initial value once and
+ * persists it before returning.
+ */
+export const getCohort = (): string => {
+  const cachedCohort = sessionState.getCachedCohort();
+  if (cachedCohort !== undefined) {
+    return cachedCohort;
+  }
+
+  const cohort = normalizeAndValidateCohort(HotUpdaterNative.getCohort());
+  sessionState.cacheCohort(cohort);
+  return cohort;
+};

package/src/specs/NativeHotUpdater.ts

@@ -1,5 +1,6 @@
 import type { TurboModule } from "react-native";
 import { TurboModuleRegistry } from "react-native";
+import type { UnsafeObject } from "react-native/Libraries/Types/CodegenTypes";
 
 export interface UpdateBundleParams {
   bundleId: string;
@@ -105,6 +106,37 @@ export interface Spec extends TurboModule {
    */
   getBaseURL: () => string;
 
+  /**
+   * Gets the current active bundle ID from native bundle storage.
+   * Native reads the extracted bundle manifest first and falls back to the
+   * legacy BUNDLE_ID file when needed. Built-in bundle fallback is handled in JS.
+   *
+   * @returns Active bundle ID from bundle storage, or null when unavailable
+   */
+  getBundleId: () => string | null;
+
+  /**
+   * Gets the current manifest from native bundle storage.
+   * Returns an empty object when manifest.json is missing or invalid.
+   */
+  getManifest: () => UnsafeObject;
+
+  /**
+   * Sets the persisted cohort used for rollout calculations.
+   *
+   * Native only derives a device-based cohort when nothing has been stored
+   * yet. Call `getCohort()` first if the app needs to save that initial value
+   * for a later restore.
+   */
+  setCohort: (cohort: string) => void;
+
+  /**
+   * Gets the persisted cohort used for rollout calculations.
+   * If none has been stored yet, native derives the initial value once and
+   * persists it before returning.
+   */
+  getCohort: () => string;
+
   // EventEmitter
   addListener(eventName: string): void;
   removeListeners(count: number): void;

package/src/types.ts

@@ -30,6 +30,11 @@ export interface ResolverCheckUpdateParams {
    */
   channel: string;
 
+  /**
+   * Cohort identifier used for server-side rollout decisions.
+   */
+  cohort: string;
+
   /**
    * Update strategy being used
    */

package/src/wrap.tsx

@@ -55,7 +55,7 @@ interface CommonHotUpdaterOptions {
    *   updateMode: "manual",
    *   onNotifyAppReady: ({ status, crashedBundleId }) => {
    *     if (status === "RECOVERED") {
-   *       analytics.track('bundle_rollback', { crashedBundleId });
+   *       analytics.track("bundle_rollback", { crashedBundleId });
    *     }
    *   }
    * })(App);

package/lib/typescript/commonjs/native.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=native.spec.d.ts.map

package/lib/typescript/commonjs/native.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"native.spec.d.ts","sourceRoot":"","sources":["../../../src/native.spec.ts"],"names":[],"mappings":""}

package/lib/typescript/module/native.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=native.spec.d.ts.map

package/lib/typescript/module/native.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"native.spec.d.ts","sourceRoot":"","sources":["../../../src/native.spec.ts"],"names":[],"mappings":""}