@hot-updater/react-native 1.0.0-rc.16 → 1.0.0-rc.17

package/src/httpClient.spec.ts

@@ -1,22 +1,14 @@
-import {
-  isUUIDv7,
-  type ArtifactInfo,
-  type ReleaseCatalog,
-} from "@hot-updater/core";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import { FetchJSONResponseError } from "./fetchJSON";
-import { createHttpClient, type InsightsEventParams } from "./httpClient";
+import { createHttpClient } from "./httpClient";
+import { InvalidUpdateResponseError } from "./updateError";
 
-const mocks = vi.hoisted(() => {
-  Reflect.set(globalThis, "HotUpdater", {
-    SDK_VERSION: "test-sdk-version",
-  });
-  return {
-    fetchCatalog: vi.fn(),
-    fetchJSON: vi.fn(),
-  };
-});
+const mocks = vi.hoisted(() => ({
+  fetchCatalog: vi.fn(),
+  fetchJSON: vi.fn(),
+}));
 
 vi.mock("./releaseCatalogCache", () => ({
   fetchReleaseCatalogWithCache: mocks.fetchCatalog,
@@ -193,221 +185,32 @@ describe("private HotUpdater HTTP client", () => {
     ).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",
-    );
-  });
-});
-
-const unchangedEvent: InsightsEventParams = {
-  appVersion: "1.0.0",
-  channel: "production",
-  cohort: "123",
-  fingerprintHash: null,
-  fromBundleId: null,
-  installId: "install-id",
-  platform: "ios",
-  toBundleId: "bundle-id",
-  type: "UNCHANGED",
-  updateStrategy: null,
-};
-
-/** Answers each POST /events with the next response, then 204. */
-const stubEventsEndpoint = (...responses: (number | Response | Error)[]) => {
-  const fetchMock = vi.fn<typeof fetch>(async () => {
-    const next = responses.shift() ?? 204;
-    if (next instanceof Error) throw next;
-    return typeof next === "number"
-      ? new Response(null, { status: next })
-      : next;
-  });
-  vi.stubGlobal("fetch", fetchMock);
-  const sentEvents = () =>
-    fetchMock.mock.calls.map(
-      ([, request]) =>
-        JSON.parse(String(request?.body)) as {
-          eventId: string;
-          type: string;
-        },
-    );
-  return { fetchMock, sentEvents };
-};
-
-describe("Insights event delivery", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    // No jitter: the first retry waits exactly 1 s and the second 2 s.
-    vi.spyOn(Math, "random").mockReturnValue(0.5);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-  });
-
-  const createSession = () =>
-    createHttpClient("https://updates.example.com").createSession();
-
-  it("retries a 503 in the background under the same UUIDv7 eventId", async () => {
-    const { fetchMock, sentEvents } = stubEventsEndpoint(503, 204);
-    const session = await createSession();
-
-    // Settles after the failed first attempt, without waiting for the retry.
-    await session.sendInsightsEvent(unchangedEvent);
-    expect(fetchMock).toHaveBeenCalledOnce();
-
-    await vi.advanceTimersByTimeAsync(1_000);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    const [first, second] = sentEvents();
-    expect(isUUIDv7(first?.eventId)).toBe(true);
-    expect(second?.eventId).toBe(first?.eventId);
-  });
-
-  it("waits for a 429's Retry-After before the next attempt", async () => {
-    const { fetchMock } = stubEventsEndpoint(
-      new Response(null, { headers: { "Retry-After": "7" }, status: 429 }),
-    );
-    const session = await createSession();
-
-    await session.sendInsightsEvent(unchangedEvent);
-    await vi.advanceTimersByTimeAsync(6_999);
-    expect(fetchMock).toHaveBeenCalledOnce();
-    await vi.advanceTimersByTimeAsync(1);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("caps a server's Retry-After at 30 seconds", async () => {
-    const { fetchMock } = stubEventsEndpoint(
-      new Response(null, { headers: { "Retry-After": "3600" }, status: 503 }),
-    );
-    const session = await createSession();
-
-    await session.sendInsightsEvent(unchangedEvent);
-    await vi.advanceTimersByTimeAsync(29_999);
-    expect(fetchMock).toHaveBeenCalledOnce();
-    await vi.advanceTimersByTimeAsync(1);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("does not retry a 400", async () => {
-    const { fetchMock } = stubEventsEndpoint(400);
-    const session = await createSession();
-
-    await expect(session.sendInsightsEvent(unchangedEvent)).rejects.toThrow(
-      "Expected HTTP 204 from /events, received 400",
-    );
-    await vi.runAllTimersAsync();
-    expect(fetchMock).toHaveBeenCalledOnce();
-  });
-
-  it("stops after three attempts and warns once", async () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const { fetchMock } = stubEventsEndpoint(
-      500,
-      new Error("network unavailable"),
-      503,
-    );
-    const session = await createSession();
-
-    await session.sendInsightsEvent(unchangedEvent);
-    await vi.runAllTimersAsync();
+  it.each([
+    { label: "a legacy response", response: { fileUrl: "/storage/a.zip" } },
+    {
+      label: "an invalid absolute URL",
+      response: {
+        ...artifact,
+        manifestUrl: "https://",
+      },
+    },
+  ])("marks $label as an invalid update response", async ({ response }) => {
+    mocks.fetchJSON.mockResolvedValue(response);
+    const session = await createHttpClient(
+      "https://updates.example.com",
+    ).createSession();
 
-    expect(fetchMock).toHaveBeenCalledTimes(3);
-    expect(warn).toHaveBeenCalledExactlyOnceWith(
-      "[HotUpdater] Insights UNCHANGED event was not delivered:",
-      expect.objectContaining({
-        message: "Expected HTTP 204 from /events, received 503",
+    await expect(
+      session.resolveArtifact({
+        currentBundleId: "current",
+        targetBundleId: "target",
       }),
-    );
+    ).rejects.toBeInstanceOf(InvalidUpdateResponseError);
   });
 
-  it("gives each attempt its own timeout", async () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const fetchMock = vi.fn<typeof fetch>(
-      (_input, request) =>
-        new Promise((_resolve, reject) => {
-          request?.signal?.addEventListener("abort", () => {
-            reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
-          });
-        }),
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    const session = await createSession();
-
-    const sent = session.sendInsightsEvent({
-      ...unchangedEvent,
-      requestTimeout: 2_000,
-    });
-    await vi.advanceTimersByTimeAsync(2_000);
-    await sent;
-    // The second attempt starts after a 1 s backoff and gets a full 2 s.
-    await vi.advanceTimersByTimeAsync(1_000);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    const secondSignal = fetchMock.mock.calls[1]?.[1]?.signal;
-    await vi.advanceTimersByTimeAsync(1_999);
-    expect(secondSignal?.aborted).toBe(false);
-    await vi.advanceTimersByTimeAsync(1);
-    expect(secondSignal?.aborted).toBe(true);
-    await vi.runAllTimersAsync();
-
-    expect(fetchMock).toHaveBeenCalledTimes(3);
-    expect(warn).toHaveBeenCalledExactlyOnceWith(
-      "[HotUpdater] Insights UNCHANGED event was not delivered:",
-      expect.objectContaining({ message: "Request timed out" }),
+  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",
     );
   });
-
-  it("sends a later event after an earlier event's retries without holding its caller", async () => {
-    const { fetchMock, sentEvents } = stubEventsEndpoint(503);
-    const session = await createSession();
-
-    await session.sendInsightsEvent(unchangedEvent);
-    await session.sendInsightsEvent({
-      ...unchangedEvent,
-      fromBundleId: "bundle-id",
-      toBundleId: "next-bundle-id",
-      type: "UPDATE_DOWNLOADED",
-      updateStrategy: "appVersion",
-    });
-    expect(fetchMock).toHaveBeenCalledOnce();
-
-    await vi.runAllTimersAsync();
-    const [first, retry, later] = sentEvents();
-    expect([first?.type, retry?.type, later?.type]).toEqual([
-      "UNCHANGED",
-      "UNCHANGED",
-      "UPDATE_DOWNLOADED",
-    ]);
-    expect(retry?.eventId).toBe(first?.eventId);
-    expect(later?.eventId).not.toBe(first?.eventId);
-  });
-
-  it("keeps sending events after one fails outside its requests", async () => {
-    vi.spyOn(console, "warn").mockImplementation(() => {
-      throw new Error("console unavailable");
-    });
-    const { fetchMock, sentEvents } = stubEventsEndpoint(500, 500, 500);
-    const session = await createSession();
-
-    await session.sendInsightsEvent(unchangedEvent);
-    await vi.runAllTimersAsync();
-    expect(fetchMock).toHaveBeenCalledTimes(3);
-
-    // A queue left rejected would never send this event or settle its caller.
-    await session.sendInsightsEvent({
-      ...unchangedEvent,
-      fromBundleId: "bundle-id",
-      toBundleId: "next-bundle-id",
-      type: "UPDATE_DOWNLOADED",
-      updateStrategy: "appVersion",
-    });
-    expect(sentEvents().map(({ type }) => type)).toEqual([
-      "UNCHANGED",
-      "UNCHANGED",
-      "UNCHANGED",
-      "UPDATE_DOWNLOADED",
-    ]);
-  });
 });

package/src/httpClient.ts

@@ -6,11 +6,11 @@ import {
 } from "@hot-updater/core";
 import { canonicalizeAppVersion } from "@hot-updater/plugin-core";
 
+import { resolveBaseURL } from "./baseURL";
 import { fetchJSON, FetchJSONResponseError } from "./fetchJSON";
 import { fetchReleaseCatalogWithCache } from "./releaseCatalogCache";
-import { HOT_UPDATER_SDK_VERSION } from "./sdkVersion";
 import type { HotUpdaterBaseURL } from "./types";
-import { createUUIDv7 } from "./uuidv7";
+import { InvalidUpdateResponseError } from "./updateError";
 
 export interface ReleaseCatalogRequest {
   readonly platform: "ios" | "android";
@@ -29,75 +29,31 @@ export interface ArtifactRequest {
   readonly requestTimeout?: number;
 }
 
-interface InsightsEventCommonParams {
-  readonly installId: string;
-  readonly userId?: string;
-  readonly username?: string;
-  readonly platform: "ios" | "android";
-  readonly appVersion: string;
-  readonly channel: string;
-  readonly cohort: string;
-  readonly fingerprintHash: string | null;
-  readonly fromReleaseId?: string | null;
-  readonly toReleaseId?: string | null;
-  readonly requestHeaders?: Record<string, string>;
-  readonly requestTimeout?: number;
-}
-
-type InsightsTransitionEventParams = InsightsEventCommonParams & {
-  readonly type: "UPDATE_DOWNLOADED" | "UPDATE_APPLIED" | "RECOVERED";
-  readonly fromBundleId: string;
-  readonly toBundleId: string;
-  readonly updateStrategy: "fingerprint" | "appVersion";
-};
-
-type InsightsUnchangedEventParams = InsightsEventCommonParams & {
-  readonly type: "UNCHANGED";
-  readonly fromBundleId: null;
-  readonly toBundleId: string;
-  readonly updateStrategy: null;
-};
-
-export type InsightsEventParams =
-  | InsightsTransitionEventParams
-  | InsightsUnchangedEventParams;
-
 export interface HotUpdaterHttpSession {
+  /** Resolves to null when the server says the scope has no catalog, so no update. */
   fetchReleaseCatalog: (
     params: ReleaseCatalogRequest,
-  ) => Promise<ReleaseCatalog>;
+  ) => Promise<ReleaseCatalog | null>;
   resolveArtifact: (params: ArtifactRequest) => Promise<ArtifactInfo>;
-  /**
-   * Posts an Insights event under a client `eventId`, retrying a network
-   * error, timeout, 429 or 5xx for up to three attempts in all. Resolves once
-   * the event is delivered or left to background retries; rejects when its
-   * first attempt fails for good, such as with a 400.
-   */
-  sendInsightsEvent: (params: InsightsEventParams) => Promise<void>;
 }
 
 export interface HotUpdaterHttpClient {
   createSession: () => Promise<HotUpdaterHttpSession>;
 }
 
-const resolveBaseURL = async (baseURL: HotUpdaterBaseURL): Promise<string> => {
-  const resolvedBaseURL =
-    typeof baseURL === "function" ? await baseURL() : baseURL;
-
-  if (!resolvedBaseURL) {
-    throw new Error("baseURL function must return a non-empty string");
-  }
-
-  return resolvedBaseURL.replace(/\/+$/, "");
-};
-
 const resolveArtifactUrl = (baseURL: string, value: string): string => {
   if (/^https?:\/\//i.test(value)) {
-    new URL(value);
+    try {
+      new URL(value);
+    } catch (error) {
+      throw new InvalidUpdateResponseError(`Invalid artifact URL: ${value}`, {
+        cause: error,
+      });
+    }
     return value;
   }
   if (!value.startsWith("/storage/")) {
-    throw new Error(
+    throw new InvalidUpdateResponseError(
       "Artifact URLs must be absolute HTTP(S) URLs or client-relative storage paths.",
     );
   }
@@ -143,13 +99,13 @@ const requireArtifactProtocolV1 = (info: ArtifactInfo): ArtifactInfo => {
     !info.manifestFileHash ||
     (info.archiveUrl !== undefined && typeof info.archiveUrl !== "string")
   ) {
-    throw new Error(
+    throw new InvalidUpdateResponseError(
       `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(
+      throw new InvalidUpdateResponseError(
         "Artifact protocol 1 requires an original file for every asset.",
       );
     }
@@ -157,194 +113,8 @@ const requireArtifactProtocolV1 = (info: ArtifactInfo): ArtifactInfo => {
   return info;
 };
 
-/** Attempts per Insights event, the first one included. */
-const INSIGHTS_MAX_ATTEMPTS = 3;
-/** Wait before the second attempt; it doubles for each later attempt. */
-const INSIGHTS_RETRY_BASE_DELAY_MS = 1000;
-/** Longest wait between attempts, a server's `Retry-After` included. */
-const INSIGHTS_RETRY_MAX_DELAY_MS = 30000;
-
-type InsightsAttemptFailure = {
-  readonly error: Error;
-  /** A network error, timeout, 429 or 5xx may pass on a later attempt. */
-  readonly retryable: boolean;
-  readonly retryAfterMs: number | null;
-};
-
-/**
- * Reads `Retry-After` as delay-seconds, the form a server under load sends;
- * an HTTP-date falls back to the backoff.
- */
-const parseRetryAfterMs = (value: string | null): number | null => {
-  const seconds = value?.trim();
-  return seconds && /^\d+$/.test(seconds) ? Number(seconds) * 1000 : null;
-};
-
-const getRetryDelayMs = (
-  failedAttempt: number,
-  retryAfterMs: number | null,
-): number =>
-  Math.min(
-    retryAfterMs ??
-      // Jitter spreads the retries of installations that failed together.
-      INSIGHTS_RETRY_BASE_DELAY_MS *
-        2 ** (failedAttempt - 1) *
-        (0.5 + Math.random()),
-    INSIGHTS_RETRY_MAX_DELAY_MS,
-  );
-
-const wait = (ms: number) =>
-  new Promise<void>((resolve) => {
-    setTimeout(resolve, ms);
-  });
-
-/** Makes one POST, with its own timeout, and settles with its failure. */
-const postInsightsEvent = async (
-  baseURL: string,
-  params: InsightsEventParams,
-  eventId: string,
-): Promise<InsightsAttemptFailure | null> => {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => {
-    controller.abort();
-  }, params.requestTimeout ?? 5000);
-
-  try {
-    const response = await fetch(`${baseURL}/events`, {
-      body: JSON.stringify({
-        appVersion: params.appVersion,
-        channel: params.channel,
-        cohort: params.cohort,
-        eventId,
-        fingerprintHash: params.fingerprintHash,
-        fromBundleId: params.fromBundleId,
-        ...(params.fromReleaseId === undefined
-          ? {}
-          : { fromReleaseId: params.fromReleaseId }),
-        installId: params.installId,
-        platform: params.platform,
-        sdkVersion: HOT_UPDATER_SDK_VERSION,
-        toBundleId: params.toBundleId,
-        ...(params.toReleaseId === undefined
-          ? {}
-          : { toReleaseId: params.toReleaseId }),
-        type: params.type,
-        updateStrategy: params.updateStrategy,
-        ...(params.userId != null ? { userId: params.userId } : {}),
-        ...(params.username != null ? { username: params.username } : {}),
-      }),
-      headers: {
-        "Content-Type": "application/json",
-        ...params.requestHeaders,
-      },
-      method: "POST",
-      signal: controller.signal,
-    });
-
-    if (response.status === 204) return null;
-    return {
-      error: new Error(
-        `Expected HTTP 204 from /events, received ${response.status}`,
-      ),
-      retryable: response.status === 429 || response.status >= 500,
-      retryAfterMs: parseRetryAfterMs(response.headers.get("Retry-After")),
-    };
-  } catch (error: unknown) {
-    // fetch rejects only when no response arrived (a timeout or a network
-    // error), so a later attempt may still get through.
-    return {
-      error:
-        error instanceof Error && error.name === "AbortError"
-          ? new Error("Request timed out")
-          : error instanceof Error
-            ? error
-            : new Error(String(error)),
-      retryable: true,
-      retryAfterMs: null,
-    };
-  } finally {
-    clearTimeout(timeoutId);
-  }
-};
-
-type InsightsEventSender = (
-  baseURL: string,
-  params: InsightsEventParams,
-) => Promise<void>;
-
-/**
- * Sends Insights events one at a time and retries each in the background.
- *
- * The server keeps an installation's latest report by arrival, so a later
- * event waits behind an earlier one's retries; otherwise a retried
- * UPDATE_APPLIED could land after the UPDATE_DOWNLOADED that followed it.
- * Callers still wait only for first attempts, as they did before retries, so
- * startup, readiness and `updateBundle()` never wait out a backoff: once an
- * event backs off, every waiting caller is released, and a failure after that
- * only warns.
- */
-const createInsightsEventSender = (): InsightsEventSender => {
-  let queue = Promise.resolve();
-  let retrying = false;
-  const waiting = new Set<() => void>();
-
-  return (baseURL, params) => {
-    // One ID for every attempt, so the server counts a retried POST once.
-    const eventId = createUUIDv7();
-
-    return new Promise<void>((resolve, reject) => {
-      let released = false;
-      const release = () => {
-        released = true;
-        waiting.delete(release);
-        resolve();
-      };
-      if (retrying) release();
-      else waiting.add(release);
-
-      queue = queue.then(async () => {
-        try {
-          for (let attempt = 1; ; attempt += 1) {
-            const failure = await postInsightsEvent(baseURL, params, eventId);
-            if (failure === null) {
-              release();
-              break;
-            }
-            if (!failure.retryable || attempt === INSIGHTS_MAX_ATTEMPTS) {
-              waiting.delete(release);
-              if (released) {
-                console.warn(
-                  `[HotUpdater] Insights ${params.type} event was not delivered:`,
-                  failure.error,
-                );
-              } else {
-                reject(failure.error);
-              }
-              break;
-            }
-            retrying = true;
-            for (const releaseWaiting of waiting) releaseWaiting();
-            await wait(getRetryDelayMs(attempt, failure.retryAfterMs));
-          }
-        } catch (error: unknown) {
-          // A failed request settles in postInsightsEvent, so only a bug gets
-          // here. A rejected queue would leave every later event, and a caller
-          // such as `updateBundle()` waiting on one, pending forever.
-          waiting.delete(release);
-          if (!released) reject(error);
-        } finally {
-          retrying = false;
-        }
-      });
-    });
-  };
-};
-
-const createSession = (
-  baseURL: string,
-  sendInsightsEvent: InsightsEventSender,
-): HotUpdaterHttpSession => ({
-  fetchReleaseCatalog: async (params): Promise<ReleaseCatalog> => {
+const createSession = (baseURL: string): HotUpdaterHttpSession => ({
+  fetchReleaseCatalog: async (params): Promise<ReleaseCatalog | null> => {
     const channelKey = encodeChannelKey(params.channel);
     let strategyValue: string;
     if (params.updateStrategy === "fingerprint") {
@@ -393,7 +163,7 @@ const createSession = (
       });
     } catch (error) {
       if (error instanceof FetchJSONResponseError && error.status === 404) {
-        throw new Error(
+        throw new InvalidUpdateResponseError(
           `Server does not support artifact protocol ${ARTIFACT_PROTOCOL_VERSION}.`,
           { cause: error },
         );
@@ -402,17 +172,11 @@ const createSession = (
     }
     return resolveArtifactUrls(baseURL, requireArtifactProtocolV1(info));
   },
-  sendInsightsEvent: (params) => sendInsightsEvent(baseURL, params),
 });
 
 /** Creates the private HTTP client used by HotUpdater.init and HotUpdater.wrap. */
 export const createHttpClient = (
   baseURL: HotUpdaterBaseURL,
-): HotUpdaterHttpClient => {
-  // Shared by every session, since each report opens its own session.
-  const sendInsightsEvent = createInsightsEventSender();
-  return {
-    createSession: async () =>
-      createSession(await resolveBaseURL(baseURL), sendInsightsEvent),
-  };
-};
+): HotUpdaterHttpClient => ({
+  createSession: async () => createSession(await resolveBaseURL(baseURL)),
+});