@hot-updater/react-native 1.0.6 → 1.0.7

package/src/native.ts

@@ -1,6 +1,7 @@
 import {
   type ArtifactAsset,
   type CatalogHighWater,
+  type ChangedAssetPatch,
   INVALID_COHORT_ERROR_MESSAGE,
   isValidCohort,
   normalizeCohortValue,
@@ -11,6 +12,7 @@ import { NativeEventEmitter, Platform } from "react-native";
 
 import { HotUpdaterErrorCode, isHotUpdaterError } from "./error";
 import HotUpdaterNative, {
+  type InstallArtifactParams,
   type UpdateBundleParams,
 } from "./specs/NativeHotUpdater";
 
@@ -298,6 +300,25 @@ export type UpdateParams = UpdateBundleParams & {
   shouldSkipCurrentBundleIdCheck?: boolean;
 };
 
+/** How the update check stages a Bundle over artifact protocol v2. */
+export type InstallArtifactUpdateParams = Omit<
+  InstallArtifactParams,
+  "patch"
+> & {
+  patch?: (ChangedAssetPatch & { assetPath: string }) | null;
+  status: UpdateStatus;
+  shouldSkipCurrentBundleIdCheck?: boolean;
+};
+
+/**
+ * Whether native installs artifact protocol v2. Native built from an SDK
+ * older than protocol v2 has no `installArtifact`, and an OTA can bring this
+ * JavaScript to such native code, so the update check then asks for v1.
+ */
+export const supportsArtifactFiles = (): boolean =>
+  typeof (HotUpdaterNative as { installArtifact?: unknown }).installArtifact ===
+  "function";
+
 export interface ActiveUpdateState {
   readonly activeSelection: ActiveUpdateSelection | null;
   readonly stableSelection: ActiveUpdateSelection | null;
@@ -411,7 +432,7 @@ const readBundleDelivery = (value: unknown): BundleDelivery | null => {
  * @throws {Error} Rejects with error.code from HotUpdaterErrorCode enum and error.message
  */
 export async function stageBundle(
-  params: UpdateParams,
+  params: UpdateParams | InstallArtifactUpdateParams,
 ): Promise<BundleDelivery | null> {
   const updateBundleId = params.bundleId;
   const status = params.status;
@@ -447,29 +468,45 @@ export async function stageBundle(
   if (existing) return existing;
 
   const targetChannel = params.channel;
-  const targetManifestUrl = params.manifestUrl;
-  const targetManifestFileHash = params.manifestFileHash;
-  const targetAssets = params.assets;
 
   const promise = (async () => {
     try {
       const selection = params.selection;
-      const staged = await HotUpdaterNative.updateBundle({
+      const common = {
         bundleId: updateBundleId,
         channel: targetChannel,
-        assets: targetAssets as Record<string, ArtifactAsset>,
-        manifestFileHash: targetManifestFileHash,
-        manifestUrl: targetManifestUrl,
+        manifestFileHash: params.manifestFileHash,
+        manifestUrl: params.manifestUrl,
         ...(params.archiveUrl ? { archiveUrl: params.archiveUrl } : {}),
-        ...(params.filesUrl ? { filesUrl: params.filesUrl } : {}),
-        ...(params.filesUrl && params.requestHeaders
-          ? { requestHeaders: params.requestHeaders }
-          : {}),
-        ...(params.filesUrl && params.requestTimeout
-          ? { requestTimeout: params.requestTimeout }
-          : {}),
         ...(selection === undefined ? {} : { selection }),
-      });
+      };
+      const staged =
+        "assets" in params
+          ? // Legacy: artifact protocol v1, where every file comes with its
+            // URL, and the `filesUrl` form earlier releases documented, which
+            // native `updateBundle` keeps accepting.
+            await HotUpdaterNative.updateBundle({
+              ...common,
+              assets: params.assets as Record<string, ArtifactAsset>,
+              ...(params.filesUrl ? { filesUrl: params.filesUrl } : {}),
+              ...(params.filesUrl && params.requestHeaders
+                ? { requestHeaders: params.requestHeaders }
+                : {}),
+              ...(params.filesUrl && params.requestTimeout
+                ? { requestTimeout: params.requestTimeout }
+                : {}),
+            })
+          : await HotUpdaterNative.installArtifact({
+              ...common,
+              filesUrl: params.filesUrl,
+              ...(params.patch ? { patch: params.patch } : {}),
+              ...(params.requestHeaders
+                ? { requestHeaders: params.requestHeaders }
+                : {}),
+              ...(params.requestTimeout
+                ? { requestTimeout: params.requestTimeout }
+                : {}),
+            });
       sessionState.markBundleInstalled(updateBundleId, targetChannel);
       return readBundleDelivery(staged);
     } finally {

package/src/sdkVersion.ts

@@ -1 +1 @@
-export const HOT_UPDATER_SDK_VERSION = "1.0.6";
+export const HOT_UPDATER_SDK_VERSION = "1.0.7";

package/src/specs/NativeHotUpdater.ts

@@ -15,21 +15,40 @@ export interface UpdateBundleParams {
   manifestFileHash: string;
   /** Optional tar.br URL; integrity and sizes come from the verified manifest. */
   archiveUrl?: string | null;
-  /**
-   * Target file descriptors: every file with its URL in artifact protocol v1,
-   * or only the Hermes patch in v2, where native asks `filesUrl`.
-   */
+  /** Every target file with its download URL and optional Hermes patch. */
   assets: UnsafeObject;
   /**
-   * Artifact protocol v2: where native POSTs the paths of the files it
-   * downloads one by one, after reusing local files and choosing the archive.
+   * Legacy: JavaScript from the first artifact protocol v2 SDK sends these
+   * here, with only the Hermes patch in `assets`, and apps may pass them to
+   * `updateBundle` as that release documented. Native keeps accepting them so
+   * such OTA Bundles still install. The update check sends them to
+   * `installArtifact`.
    */
   filesUrl?: string | null;
+  requestHeaders?: UnsafeObject | null;
+  requestTimeout?: number | null;
+  /** Full Release Catalog selection receipt committed with the staged Bundle. */
+  selection?: UnsafeObject | null;
+}
+
+/**
+ * Artifact protocol v2: no URL per file. Native reuses local files, chooses
+ * the archive or files, and POSTs the paths it downloads one by one to
+ * `filesUrl` for their URLs.
+ */
+export interface InstallArtifactParams {
+  bundleId: string;
+  channel?: string;
+  manifestUrl: string;
+  manifestFileHash: string;
+  archiveUrl?: string | null;
+  /** The Hermes bytecode patch from the running Bundle, with its `assetPath`. */
+  patch?: UnsafeObject | null;
+  filesUrl: string;
   /** Headers for the `filesUrl` request, as the update check sent them. */
   requestHeaders?: UnsafeObject | null;
   /** Milliseconds the `filesUrl` request may take, as the update check's. */
   requestTimeout?: number | null;
-  /** Full Release Catalog selection receipt committed with the staged Bundle. */
   selection?: UnsafeObject | null;
 }
 
@@ -90,6 +109,13 @@ export interface Spec extends TurboModule {
    */
   updateBundle(params: UpdateBundleParams): Promise<UnsafeObject>;
 
+  /**
+   * Stages a Bundle over artifact protocol v2 and resolves like
+   * `updateBundle`. Native built from an SDK older than protocol v2 lacks
+   * it, so JS checks for it before asking the server for v2.
+   */
+  installArtifact(params: InstallArtifactParams): Promise<UnsafeObject>;
+
   /** Accepts and durably advances the catalog high-water for a scope. */
   acceptReleaseCatalog(params: UnsafeObject): boolean;