@hot-updater/react-native 1.0.0-rc.1 → 1.0.0-rc.15

package/src/httpClient.spec.ts

@@ -1,6 +1,7 @@
 import type { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+import { FetchJSONResponseError } from "./fetchJSON";
 import { createHttpClient } from "./httpClient";
 
 const mocks = vi.hoisted(() => {
@@ -18,12 +19,28 @@ vi.mock("./releaseCatalogCache", () => ({
 }));
 
 vi.mock("./fetchJSON", () => ({
+  FetchJSONResponseError: class FetchJSONResponseError extends Error {
+    constructor(
+      readonly status: number,
+      statusText: string,
+    ) {
+      super(statusText);
+    }
+  },
   fetchJSON: mocks.fetchJSON,
 }));
 
 const artifact: ArtifactInfo = {
-  fileHash: "bundle-hash",
-  fileUrl: "/storage/bundle.zip",
+  artifactProtocolVersion: 1,
+  assets: {
+    "index.ios.bundle": {
+      file: { url: "/storage/index.bundle.br" },
+      fileHash: "bundle-hash",
+    },
+  },
+  manifestFileHash: "manifest-hash",
+  manifestUrl: "/storage/manifest.json",
+  archiveUrl: "/storage/bundle.tar.br",
 };
 
 const catalog: ReleaseCatalog = {
@@ -93,14 +110,24 @@ describe("private HotUpdater HTTP client", () => {
       }),
     ).resolves.toEqual({
       ...artifact,
-      fileUrl: "https://first.example.com/hot-updater/storage/bundle.zip",
+      assets: {
+        "index.ios.bundle": {
+          file: {
+            url: "https://first.example.com/hot-updater/storage/index.bundle.br",
+          },
+          fileHash: "bundle-hash",
+        },
+      },
+      manifestUrl:
+        "https://first.example.com/hot-updater/storage/manifest.json",
+      archiveUrl: "https://first.example.com/hot-updater/storage/bundle.tar.br",
     });
 
     expect(resolveBaseURL).toHaveBeenCalledOnce();
     expect(mocks.fetchJSON).toHaveBeenCalledWith({
       requestHeaders: undefined,
       requestTimeout: undefined,
-      url: "https://first.example.com/hot-updater/artifacts/target/from/current",
+      url: "https://first.example.com/hot-updater/artifacts/v1/target/from/current",
     });
 
     await client.createSession();
@@ -110,7 +137,12 @@ describe("private HotUpdater HTTP client", () => {
   it("rejects non-storage relative artifact URLs", async () => {
     mocks.fetchJSON.mockResolvedValue({
       ...artifact,
-      fileUrl: "/private/bundle.zip",
+      assets: {
+        "index.ios.bundle": {
+          file: { url: "/private/index.bundle.br" },
+          fileHash: "bundle-hash",
+        },
+      },
     });
     const session = await createHttpClient(
       "https://updates.example.com",
@@ -124,6 +156,39 @@ describe("private HotUpdater HTTP client", () => {
     ).rejects.toThrow("client-relative storage paths");
   });
 
+  it("rejects a legacy artifact response", async () => {
+    mocks.fetchJSON.mockResolvedValue({
+      fileHash: "archive-hash",
+      fileUrl: "/storage/bundle.zip",
+    });
+    const session = await createHttpClient(
+      "https://updates.example.com",
+    ).createSession();
+
+    await expect(
+      session.resolveArtifact({
+        currentBundleId: "current",
+        targetBundleId: "target",
+      }),
+    ).rejects.toThrow("does not support artifact protocol 1");
+  });
+
+  it("reports an old server without the v1 endpoint explicitly", async () => {
+    mocks.fetchJSON.mockRejectedValue(
+      new FetchJSONResponseError(404, "Not Found"),
+    );
+    const session = await createHttpClient(
+      "https://updates.example.com",
+    ).createSession();
+
+    await expect(
+      session.resolveArtifact({
+        currentBundleId: "current",
+        targetBundleId: "target",
+      }),
+    ).rejects.toThrow("does not support artifact protocol 1");
+  });
+
   it("requires a functional baseURL to resolve to a non-empty string", async () => {
     await expect(createHttpClient(() => "").createSession()).rejects.toThrow(
       "baseURL function must return a non-empty string",

package/src/httpClient.ts

@@ -1,11 +1,12 @@
 import {
+  ARTIFACT_PROTOCOL_VERSION,
   encodeChannelKey,
   type ArtifactInfo,
   type ReleaseCatalog,
 } from "@hot-updater/core";
 import { canonicalizeAppVersion } from "@hot-updater/plugin-core";
 
-import { fetchJSON } from "./fetchJSON";
+import { fetchJSON, FetchJSONResponseError } from "./fetchJSON";
 import { fetchReleaseCatalogWithCache } from "./releaseCatalogCache";
 import { HOT_UPDATER_SDK_VERSION } from "./sdkVersion";
 import type { HotUpdaterBaseURL } from "./types";
@@ -27,7 +28,7 @@ export interface ArtifactRequest {
   readonly requestTimeout?: number;
 }
 
-interface AnalyticsEventCommonParams {
+interface InsightsEventCommonParams {
   readonly installId: string;
   readonly userId?: string;
   readonly username?: string;
@@ -42,30 +43,30 @@ interface AnalyticsEventCommonParams {
   readonly requestTimeout?: number;
 }
 
-type AnalyticsTransitionEventParams = AnalyticsEventCommonParams & {
-  readonly type: "UPDATE_APPLIED" | "RECOVERED" | "RELEASE_ADOPTED";
+type InsightsTransitionEventParams = InsightsEventCommonParams & {
+  readonly type: "UPDATE_DOWNLOADED" | "UPDATE_APPLIED" | "RECOVERED";
   readonly fromBundleId: string;
   readonly toBundleId: string;
   readonly updateStrategy: "fingerprint" | "appVersion";
 };
 
-type AnalyticsUnchangedEventParams = AnalyticsEventCommonParams & {
+type InsightsUnchangedEventParams = InsightsEventCommonParams & {
   readonly type: "UNCHANGED";
   readonly fromBundleId: null;
   readonly toBundleId: string;
   readonly updateStrategy: null;
 };
 
-export type AnalyticsEventParams =
-  | AnalyticsTransitionEventParams
-  | AnalyticsUnchangedEventParams;
+export type InsightsEventParams =
+  | InsightsTransitionEventParams
+  | InsightsUnchangedEventParams;
 
 export interface HotUpdaterHttpSession {
   fetchReleaseCatalog: (
     params: ReleaseCatalogRequest,
   ) => Promise<ReleaseCatalog>;
   resolveArtifact: (params: ArtifactRequest) => Promise<ArtifactInfo>;
-  sendAnalyticsEvent: (params: AnalyticsEventParams) => Promise<void>;
+  sendInsightsEvent: (params: InsightsEventParams) => Promise<void>;
 }
 
 export interface HotUpdaterHttpClient {
@@ -101,55 +102,57 @@ const resolveArtifactUrls = (
   info: ArtifactInfo,
 ): ArtifactInfo => ({
   ...info,
-  fileUrl:
-    info.fileUrl === null ? null : resolveArtifactUrl(baseURL, info.fileUrl),
-  ...(info.manifestUrl === undefined
-    ? {}
-    : {
-        manifestUrl:
-          info.manifestUrl === null
-            ? null
-            : resolveArtifactUrl(baseURL, info.manifestUrl),
-      }),
-  ...(info.changedAssets === undefined
-    ? {}
-    : {
-        changedAssets:
-          info.changedAssets === null
-            ? null
-            : Object.fromEntries(
-                Object.entries(info.changedAssets).map(([path, asset]) => [
-                  path,
-                  {
-                    ...asset,
-                    ...(asset.file
-                      ? {
-                          file: {
-                            ...asset.file,
-                            url: resolveArtifactUrl(baseURL, asset.file.url),
-                          },
-                        }
-                      : {}),
-                    ...(asset.patch
-                      ? {
-                          patch: {
-                            ...asset.patch,
-                            patchUrl: resolveArtifactUrl(
-                              baseURL,
-                              asset.patch.patchUrl,
-                            ),
-                          },
-                        }
-                      : {}),
-                  },
-                ]),
-              ),
-      }),
+  manifestUrl: resolveArtifactUrl(baseURL, info.manifestUrl),
+  ...(info.archiveUrl
+    ? { archiveUrl: resolveArtifactUrl(baseURL, info.archiveUrl) }
+    : {}),
+  assets: Object.fromEntries(
+    Object.entries(info.assets).map(([path, asset]) => [
+      path,
+      {
+        ...asset,
+        file: {
+          ...asset.file,
+          url: resolveArtifactUrl(baseURL, asset.file.url),
+        },
+        ...(asset.patch
+          ? {
+              patch: {
+                ...asset.patch,
+                patchUrl: resolveArtifactUrl(baseURL, asset.patch.patchUrl),
+              },
+            }
+          : {}),
+      },
+    ]),
+  ),
 });
 
-const sendAnalyticsEvent = async (
+const requireArtifactProtocolV1 = (info: ArtifactInfo): ArtifactInfo => {
+  if (
+    info.artifactProtocolVersion !== ARTIFACT_PROTOCOL_VERSION ||
+    !info.assets ||
+    !info.manifestUrl ||
+    !info.manifestFileHash ||
+    (info.archiveUrl !== undefined && typeof info.archiveUrl !== "string")
+  ) {
+    throw new Error(
+      `Server does not support artifact protocol ${ARTIFACT_PROTOCOL_VERSION}.`,
+    );
+  }
+  for (const asset of Object.values(info.assets)) {
+    if (!asset.file?.url || !asset.fileHash) {
+      throw new Error(
+        "Artifact protocol 1 requires an original file for every asset.",
+      );
+    }
+  }
+  return info;
+};
+
+const sendInsightsEvent = async (
   baseURL: string,
-  params: AnalyticsEventParams,
+  params: InsightsEventParams,
 ): Promise<void> => {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => {
@@ -241,16 +244,27 @@ const createSession = (baseURL: string): HotUpdaterHttpSession => ({
     });
   },
   resolveArtifact: async (params): Promise<ArtifactInfo> => {
-    const info = await fetchJSON<ArtifactInfo>({
-      requestHeaders: params.requestHeaders,
-      requestTimeout: params.requestTimeout,
-      url: `${baseURL}/artifacts/${encodeURIComponent(
-        params.targetBundleId,
-      )}/from/${encodeURIComponent(params.currentBundleId)}`,
-    });
-    return resolveArtifactUrls(baseURL, info);
+    let info: ArtifactInfo;
+    try {
+      info = await fetchJSON<ArtifactInfo>({
+        requestHeaders: params.requestHeaders,
+        requestTimeout: params.requestTimeout,
+        url: `${baseURL}/artifacts/v1/${encodeURIComponent(
+          params.targetBundleId,
+        )}/from/${encodeURIComponent(params.currentBundleId)}`,
+      });
+    } catch (error) {
+      if (error instanceof FetchJSONResponseError && error.status === 404) {
+        throw new Error(
+          `Server does not support artifact protocol ${ARTIFACT_PROTOCOL_VERSION}.`,
+          { cause: error },
+        );
+      }
+      throw error;
+    }
+    return resolveArtifactUrls(baseURL, requireArtifactProtocolV1(info));
   },
-  sendAnalyticsEvent: (params) => sendAnalyticsEvent(baseURL, params),
+  sendInsightsEvent: (params) => sendInsightsEvent(baseURL, params),
 });
 
 /** Creates the private HTTP client used by HotUpdater.init and HotUpdater.wrap. */

package/src/index.spec.ts

@@ -22,7 +22,7 @@ const mocks = vi.hoisted(() => {
     })),
     getAppVersion: vi.fn(() => "1.0.0"),
     getBaseURL: vi.fn(() => null),
-    getBundleId: vi.fn(() => "bundle-id"),
+    getUpdateId: vi.fn(() => "release-id"),
     getChannel: vi.fn(() => "production"),
     getCohort: vi.fn(() => "123"),
     getCrashHistory: vi.fn(() => []),
@@ -31,7 +31,6 @@ const mocks = vi.hoisted(() => {
     getInstallId: vi.fn(() => "install-id"),
     getManifest: vi.fn(() => null),
     getMinBundleId: vi.fn(() => "min-bundle-id"),
-    getReleaseId: vi.fn(async () => null),
     init: vi.fn(),
     isChannelSwitched: vi.fn(() => false),
     notifyAppReady: vi.fn(() => ({ status: "UNCHANGED" as const })),
@@ -45,6 +44,8 @@ const mocks = vi.hoisted(() => {
   };
 });
 
+vi.mock("react-native", () => ({ Platform: { OS: "ios" } }));
+
 vi.mock("./httpClient", () => ({
   createHttpClient: mocks.createHttpClient,
 }));
@@ -57,9 +58,11 @@ vi.mock("./native", () => ({
   addListener: mocks.addListener,
   clearCrashHistory: mocks.clearCrashHistory,
   getPublicActiveUpdateState: mocks.getActiveUpdateState,
+  getActiveUpdateState: mocks.getActiveUpdateState,
+  getBundleId: () => "bundle-id",
   getAppVersion: mocks.getAppVersion,
   getBaseURL: mocks.getBaseURL,
-  getBundleId: mocks.getBundleId,
+  getUpdateId: mocks.getUpdateId,
   getChannel: mocks.getChannel,
   getCohort: mocks.getCohort,
   getCrashHistory: mocks.getCrashHistory,
@@ -68,7 +71,6 @@ vi.mock("./native", () => ({
   getInstallId: mocks.getInstallId,
   getManifest: mocks.getManifest,
   getMinBundleId: mocks.getMinBundleId,
-  getReleaseId: mocks.getReleaseId,
   isChannelSwitched: mocks.isChannelSwitched,
   notifyAppReady: mocks.notifyAppReady,
   reload: mocks.reload,
@@ -97,13 +99,21 @@ describe("HotUpdater client initialization", () => {
     mocks.wrap.mockImplementation((Component: unknown) => Component);
   });
 
+  it("exposes the console ID through the existing getter only", async () => {
+    const HotUpdater = await importHotUpdater();
+
+    expect(HotUpdater.getBundleId()).toBe("release-id");
+    expect(HotUpdater).not.toHaveProperty("getReleaseId");
+    expect(HotUpdater).not.toHaveProperty("getUpdateId");
+  });
+
   it("initializes a private HTTP client from the required baseURL", async () => {
     const client = { createSession: vi.fn() };
     mocks.createHttpClient.mockReturnValue(client as never);
     const HotUpdater = await importHotUpdater();
 
     HotUpdater.init({
-      analytics: true,
+      insights: true,
       baseURL: "https://updates.example.com",
       requestHeaders: { Authorization: "Bearer token" },
       requestTimeout: 1000,
@@ -113,7 +123,7 @@ describe("HotUpdater client initialization", () => {
       "https://updates.example.com",
     );
     expect(mocks.init).toHaveBeenCalledWith({
-      analytics: true,
+      insights: true,
       client,
       requestHeaders: { Authorization: "Bearer token" },
       requestTimeout: 1000,
@@ -130,6 +140,44 @@ describe("HotUpdater client initialization", () => {
     expect(resolveBaseURL).not.toHaveBeenCalled();
   });
 
+  it("enables insights by default for init and wrap", async () => {
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({ baseURL: "https://updates.example.com" });
+    HotUpdater.wrap({
+      baseURL: "https://updates.example.com",
+      updateStrategy: "appVersion",
+    });
+
+    expect(mocks.init).toHaveBeenCalledWith(
+      expect.objectContaining({ insights: true }),
+    );
+    expect(mocks.wrap).toHaveBeenCalledWith(
+      expect.objectContaining({ insights: true }),
+    );
+  });
+
+  it("preserves an explicit insights opt-out", async () => {
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({
+      baseURL: "https://updates.example.com",
+      insights: false,
+    });
+    HotUpdater.wrap({
+      baseURL: "https://updates.example.com",
+      insights: false,
+      updateStrategy: "appVersion",
+    });
+
+    expect(mocks.init).toHaveBeenCalledWith(
+      expect.objectContaining({ insights: false }),
+    );
+    expect(mocks.wrap).toHaveBeenCalledWith(
+      expect.objectContaining({ insights: false }),
+    );
+  });
+
   it("requires baseURL and rejects the removed resolver shape", async () => {
     const HotUpdater = await importHotUpdater();
 
@@ -171,13 +219,13 @@ describe("HotUpdater client initialization", () => {
     expect(wrapOptions.updateStrategy).toBe("appVersion");
   });
 
-  it("merges settings and carries the analytics gate to checks", async () => {
+  it("merges settings and carries the insights gate to checks", async () => {
     const client = { createSession: vi.fn() };
     mocks.createHttpClient.mockReturnValue(client as never);
     const checkOnError = vi.fn();
     const HotUpdater = await importHotUpdater();
     HotUpdater.init({
-      analytics: true,
+      insights: true,
       baseURL: "https://updates.example.com",
       requestHeaders: { Authorization: "Bearer token" },
       requestTimeout: 1000,
@@ -190,7 +238,7 @@ describe("HotUpdater client initialization", () => {
     });
 
     expect(mocks.checkForUpdate).toHaveBeenCalledWith({
-      analytics: true,
+      insights: true,
       client,
       onError: checkOnError,
       requestHeaders: {
@@ -208,13 +256,13 @@ describe("HotUpdater client initialization", () => {
     const HotUpdater = await importHotUpdater();
 
     HotUpdater.wrap({
-      analytics: true,
+      insights: true,
       baseURL: "https://updates.example.com",
       updateStrategy: "appVersion",
     });
 
     expect(mocks.wrap).toHaveBeenCalledWith({
-      analytics: true,
+      insights: true,
       client,
       updateStrategy: "appVersion",
     });

package/src/index.ts

@@ -7,10 +7,12 @@ import { createHttpClient, type HotUpdaterHttpClient } from "./httpClient";
 import {
   addListener,
   getPublicActiveUpdateState,
+  getActiveUpdateState,
+  getBundleId,
   clearCrashHistory,
   getAppVersion,
   getBaseURL,
-  getBundleId,
+  getUpdateId,
   getChannel,
   getCohort,
   getCrashHistory,
@@ -19,7 +21,6 @@ import {
   getInstallId,
   getManifest,
   getMinBundleId,
-  getReleaseId,
   isChannelSwitched,
   notifyAppReady,
   reload,
@@ -30,6 +31,7 @@ import {
   type UpdateParams,
   updateBundle,
 } from "./native";
+import { reportBundleDownloaded } from "./notifyAppReadyInsights";
 import { hotUpdaterStore } from "./store";
 import {
   type AutoUpdateOptions,
@@ -101,12 +103,13 @@ function createHotUpdaterClient() {
 
   // Global configuration stored from wrap
   const globalConfig: {
-    analytics?: boolean;
+    insights: boolean;
     client: HotUpdaterHttpClient | null;
     requestHeaders?: Record<string, string>;
     requestTimeout?: number;
     onError?: (error: unknown) => void;
   } = {
+    insights: true,
     client: null,
   };
 
@@ -158,6 +161,7 @@ function createHotUpdaterClient() {
       const { baseURL, ...rest } = autoOptions;
       return {
         ...rest,
+        insights: rest.insights ?? true,
         client: createHttpClient(baseURL),
       };
     }
@@ -177,6 +181,7 @@ function createHotUpdaterClient() {
       const { baseURL, ...baseURLRest } = rest;
       return {
         ...baseURLRest,
+        insights: baseURLRest.insights ?? true,
         client: createHttpClient(baseURL),
       };
     }
@@ -188,7 +193,7 @@ function createHotUpdaterClient() {
     normalizedOptions: InternalInitOptions | InternalWrapOptions,
     options: HotUpdaterOptions | HotUpdaterInitOptions,
   ) => {
-    globalConfig.analytics = normalizedOptions.analytics;
+    globalConfig.insights = normalizedOptions.insights ?? true;
     globalConfig.client = normalizedOptions.client;
     globalConfig.requestHeaders = options.requestHeaders;
     globalConfig.requestTimeout = options.requestTimeout;
@@ -333,16 +338,14 @@ function createHotUpdaterClient() {
     getActiveUpdateState: async () => getPublicActiveUpdateState(),
 
     /**
-     * Fetches the current bundle ID of the app.
+     * Returns the selected update ID, matching the ID shown in the console.
+     * A staged update can change this ID before the app reloads.
      */
-    getBundleId,
+    getBundleId: getUpdateId,
 
     /** Returns the minimum bundle ID based on the native app build time. */
     getMinBundleId,
 
-    /** Returns the active Release identity, or null for BUILTIN/legacy state. */
-    getReleaseId,
-
     /**
      * Fetches the current manifest for the active bundle.
      */
@@ -448,7 +451,7 @@ function createHotUpdaterClient() {
 
       const mergedConfig: InternalCheckForUpdateOptions = {
         ...config,
-        analytics: globalConfig.analytics,
+        insights: globalConfig.insights,
         client,
         requestHeaders: {
           ...globalConfig.requestHeaders,
@@ -466,8 +469,6 @@ function createHotUpdaterClient() {
      *
      * @param {UpdateBundleParams} params - Parameters object required for bundle update
      * @param {string} params.bundleId - The bundle ID of the app
-     * @param {string|null} params.fileUrl - The URL of the zip file
-     *
      * @returns {Promise<boolean>} Whether the update was successful
      *
      * @example
@@ -491,9 +492,34 @@ function createHotUpdaterClient() {
      * }
      * ```
      */
-    updateBundle: (params: UpdateParams) => {
-      ensureGlobalClient("updateBundle");
-      return updateBundle(params);
+    updateBundle: async (params: UpdateParams) => {
+      const client = ensureGlobalClient("updateBundle");
+      const fromBundleId = getBundleId();
+      const state = getActiveUpdateState();
+      const active = state.activeSelection;
+      const downloaded = await updateBundle(params);
+      if (downloaded) {
+        const selection = getActiveUpdateState().activeSelection;
+        await reportBundleDownloaded(
+          { ...globalConfig, client },
+          {
+            fromBundleId,
+            fromReleaseId:
+              active?.bundleId === fromBundleId
+                ? active.releaseId
+                : state.stableSelection?.bundleId === fromBundleId
+                  ? state.stableSelection.releaseId
+                  : null,
+            toBundleId: params.bundleId,
+            toReleaseId: selection?.releaseId ?? null,
+            channel: params.channel ?? getChannel(),
+            updateStrategy: selection?.scopeKey?.startsWith("v1:fingerprint:")
+              ? "fingerprint"
+              : "appVersion",
+          },
+        );
+      }
+      return downloaded;
     },
 
     /**
@@ -507,10 +533,8 @@ function createHotUpdaterClient() {
         hotUpdaterStore.setState({
           artifactType: null,
           details: null,
-          downloadedBytes: undefined,
           isUpdateDownloaded: false,
           progress: 0,
-          totalBytes: undefined,
         });
       }
       return ok;