@hot-updater/react-native 1.0.4 → 1.0.6

package/src/checkForUpdate.ts

@@ -18,6 +18,7 @@ import type {
   UpdateErrorStage,
 } from "./clientPlugin";
 import { HotUpdaterError, StaleReleaseCatalogError } from "./error";
+import { DEFAULT_REQUEST_TIMEOUT_MS } from "./fetchUpdateResponse";
 import type { HotUpdaterHttpClient } from "./httpClient";
 import {
   acceptReleaseCatalog,
@@ -392,6 +393,16 @@ async function checkForReleaseCatalogUpdate(input: {
       manifestFileHash: artifact.manifestFileHash,
       manifestUrl: artifact.manifestUrl,
       ...(artifact.archiveUrl ? { archiveUrl: artifact.archiveUrl } : {}),
+      ...(artifact.filesUrl
+        ? {
+            filesUrl: artifact.filesUrl,
+            ...(options.requestHeaders
+              ? { requestHeaders: options.requestHeaders }
+              : {}),
+            requestTimeout:
+              options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS,
+          }
+        : {}),
       selection: receipt,
       shouldSkipCurrentBundleIdCheck: true,
       status: desired.status,

package/src/fetchUpdateResponse.ts

@@ -8,12 +8,15 @@ export interface UpdateRequest {
   readonly onResponse?: (response: UpdateHttpResponse) => void;
 }
 
+/** How long an update request may take when the app sets no `requestTimeout`. */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 5000;
+
 /** Read once for parsing and diagnostics, under the same request timeout. */
 export const fetchUpdateResponse = async ({
   url,
   resource,
   requestHeaders,
-  requestTimeout = 5000,
+  requestTimeout = DEFAULT_REQUEST_TIMEOUT_MS,
   onResponse,
 }: UpdateRequest): Promise<{ response: Response; body: string | null }> => {
   const controller = new AbortController();

package/src/httpClient.ts

@@ -1,15 +1,19 @@
 import {
+  ARTIFACT_FILES_PROTOCOL_VERSION,
   ARTIFACT_PROTOCOL_VERSION,
   canonicalizeAppVersion,
   encodeChannelKey,
   resolveBaseURL,
+  type ArtifactAssetFile,
   type ArtifactInfo,
+  type ArtifactInfoV2,
+  type ChangedAssetPatch,
   type HotUpdaterBaseURL,
   type ReleaseCatalog,
   type UpdateHttpResponse,
 } from "@hot-updater/protocol";
 
-import { fetchJSON } from "./fetchJSON";
+import { fetchJSON, FetchJSONResponseError } from "./fetchJSON";
 import { fetchReleaseCatalogWithCache } from "./releaseCatalogCache";
 import { InvalidUpdateResponseError } from "./updateError";
 
@@ -30,12 +34,32 @@ export interface ArtifactRequest {
   readonly requestTimeout?: number;
 }
 
+/**
+ * How native downloads a Bundle. In artifact protocol v1, `assets` holds a
+ * URL for every file. In v2, it holds only the Hermes patch, and native asks
+ * `filesUrl` for the URLs of the files it downloads one by one.
+ */
+export interface ResolvedArtifact {
+  readonly manifestUrl: string;
+  readonly manifestFileHash: string;
+  readonly archiveUrl?: string;
+  readonly assets: Record<
+    string,
+    {
+      readonly file?: ArtifactAssetFile;
+      readonly fileHash?: string;
+      readonly patch?: ChangedAssetPatch | null;
+    }
+  >;
+  readonly filesUrl?: string;
+}
+
 export interface HotUpdaterHttpSession {
   /** Resolves to null when the server says the scope has no catalog, so no update. */
   fetchReleaseCatalog: (
     params: ReleaseCatalogRequest,
   ) => Promise<ReleaseCatalog | null>;
-  resolveArtifact: (params: ArtifactRequest) => Promise<ArtifactInfo>;
+  resolveArtifact: (params: ArtifactRequest) => Promise<ResolvedArtifact>;
 }
 
 export interface HotUpdaterHttpClient {
@@ -59,6 +83,7 @@ const requireArtifactUrl = (value: string): string => {
   return value;
 };
 
+// Legacy: artifact protocol v1: validates a server that predates v2; remove with the fallback.
 const requireArtifactUrls = (info: ArtifactInfo): ArtifactInfo => {
   requireArtifactUrl(info.manifestUrl);
   if (info.archiveUrl) requireArtifactUrl(info.archiveUrl);
@@ -91,6 +116,25 @@ const requireArtifactProtocolV1 = (info: ArtifactInfo): ArtifactInfo => {
   return info;
 };
 
+const requireArtifactProtocolV2 = (info: ArtifactInfoV2): ArtifactInfoV2 => {
+  if (
+    info?.artifactProtocolVersion !== ARTIFACT_FILES_PROTOCOL_VERSION ||
+    !info.manifestUrl ||
+    !info.manifestFileHash ||
+    (info.archiveUrl !== undefined && typeof info.archiveUrl !== "string") ||
+    (info.patch !== undefined &&
+      (!info.patch?.assetPath || !info.patch.patchUrl))
+  ) {
+    throw new InvalidUpdateResponseError(
+      `Server does not support artifact protocol ${ARTIFACT_FILES_PROTOCOL_VERSION}.`,
+    );
+  }
+  requireArtifactUrl(info.manifestUrl);
+  if (info.archiveUrl) requireArtifactUrl(info.archiveUrl);
+  if (info.patch) requireArtifactUrl(info.patch.patchUrl);
+  return info;
+};
+
 const createSession = (
   baseURL: string,
   onResponse?: (response: UpdateHttpResponse) => void,
@@ -133,16 +177,47 @@ const createSession = (
       url,
     });
   },
-  resolveArtifact: async (params): Promise<ArtifactInfo> => {
-    const info = await fetchJSON<ArtifactInfo>({
+  resolveArtifact: async (params): Promise<ResolvedArtifact> => {
+    const target = encodeURIComponent(params.targetBundleId);
+    const route = `${target}/from/${encodeURIComponent(params.currentBundleId)}`;
+    const request = {
       ...(onResponse ? { onResponse } : {}),
       requestHeaders: params.requestHeaders,
       requestTimeout: params.requestTimeout,
-      url: `${baseURL}/artifacts/v1/${encodeURIComponent(
-        params.targetBundleId,
-      )}/from/${encodeURIComponent(params.currentBundleId)}`,
-    });
-    return requireArtifactUrls(requireArtifactProtocolV1(info));
+    };
+    let info: ArtifactInfoV2;
+    try {
+      info = await fetchJSON<ArtifactInfoV2>({
+        ...request,
+        url: `${baseURL}/artifacts/v2/${route}`,
+      });
+    } catch (error) {
+      // Legacy: artifact protocol v1: a server older than v2 has no such route. Remove this
+      // fallback once no supported server predates v2.
+      if (!(error instanceof FetchJSONResponseError) || error.status !== 404) {
+        throw error;
+      }
+      return requireArtifactUrls(
+        requireArtifactProtocolV1(
+          await fetchJSON<ArtifactInfo>({
+            ...request,
+            url: `${baseURL}/artifacts/v1/${route}`,
+          }),
+        ),
+      );
+    }
+    const { archiveUrl, manifestFileHash, manifestUrl, patch } =
+      requireArtifactProtocolV2(info);
+    const { assetPath, ...assetPatch } = patch ?? { assetPath: undefined };
+    return {
+      ...(archiveUrl ? { archiveUrl } : {}),
+      assets: assetPath
+        ? { [assetPath]: { patch: assetPatch as ChangedAssetPatch } }
+        : {},
+      filesUrl: `${baseURL}/artifacts/v2/${target}/files`,
+      manifestFileHash,
+      manifestUrl,
+    };
   },
 });
 

package/src/native.ts

@@ -461,6 +461,13 @@ export async function stageBundle(
         manifestFileHash: targetManifestFileHash,
         manifestUrl: targetManifestUrl,
         ...(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 }),
       });
       sessionState.markBundleInstalled(updateBundleId, targetChannel);

package/src/sdkVersion.ts

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

package/src/specs/NativeHotUpdater.ts

@@ -15,8 +15,20 @@ export interface UpdateBundleParams {
   manifestFileHash: string;
   /** Optional tar.br URL; integrity and sizes come from the verified manifest. */
   archiveUrl?: string | null;
-  /** Full protocol v1 target file descriptor map. */
+  /**
+   * Target file descriptors: every file with its URL in artifact protocol v1,
+   * or only the Hermes patch in v2, where native asks `filesUrl`.
+   */
   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.
+   */
+  filesUrl?: string | null;
+  /** 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;
 }