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

package/src/pluginHost.spec.ts

@@ -1,297 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type {
-  HotUpdaterClientContext,
-  HotUpdaterClientPlugin,
-} from "./clientPlugin";
-
-vi.mock("react-native", () => ({
-  Platform: { OS: "android" },
-}));
-
-const mocks = vi.hoisted(() => {
-  Reflect.set(globalThis, "HotUpdater", { SDK_VERSION: "test-sdk-version" });
-  return {
-    getAppVersion: vi.fn<() => string | null>(() => "1.2.3"),
-    getBundleId: vi.fn(() => "bundle-id"),
-    getChannel: vi.fn(() => "production"),
-    getCohort: vi.fn(() => "123"),
-    getFingerprintHash: vi.fn<() => string | null>(() => null),
-    getInstallId: vi.fn(() => "install-id"),
-    getStorageItem: vi.fn<(key: string) => string | null>(() => null),
-    setStorageItem: vi.fn<(key: string, value: string | null) => void>(),
-  };
-});
-
-vi.mock("./native", () => mocks);
-
-const importHost = () => import("./pluginHost");
-
-const capture = (id = "example") => {
-  let context!: HotUpdaterClientContext;
-  const setup = vi.fn((pluginContext: HotUpdaterClientContext) => {
-    context = pluginContext;
-  });
-  const plugin: HotUpdaterClientPlugin = { id, setup };
-  return { plugin, setup, context: () => context };
-};
-
-describe("client plugin host", () => {
-  beforeEach(() => {
-    vi.resetModules();
-    for (const mock of Object.values(mocks)) mock.mockClear();
-    mocks.getStorageItem.mockReturnValue(null);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-  });
-
-  it("throws at configuration for two plugins with one id", async () => {
-    const { configurePlugins } = await importHost();
-
-    expect(() =>
-      configurePlugins([capture("same").plugin, capture("same").plugin], {
-        baseURL: "https://updates.example.com",
-      }),
-    ).toThrow('Two plugins use the id "same"');
-  });
-
-  it("sets a plugin up once and stops calling a plugin left out", async () => {
-    const { configurePlugins, emitPluginHook } = await importHost();
-    const onAppReady = vi.fn();
-    const plugin: HotUpdaterClientPlugin = {
-      id: "example",
-      setup: vi.fn(() => ({ onAppReady })),
-    };
-    const config = { baseURL: "https://updates.example.com" };
-
-    configurePlugins([plugin], config);
-    configurePlugins([plugin], config);
-    emitPluginHook("onAppReady", () => ({
-      status: "UNCHANGED",
-      channel: "production",
-      bundleId: "bundle-id",
-      releaseId: null,
-      previousProcessExit: null,
-    }));
-    configurePlugins([], config);
-    emitPluginHook("onAppReady", () => ({
-      status: "UNCHANGED",
-      channel: "production",
-      bundleId: "bundle-id",
-      releaseId: null,
-      previousProcessExit: null,
-    }));
-
-    expect(plugin.setup).toHaveBeenCalledOnce();
-    expect(onAppReady).toHaveBeenCalledOnce();
-  });
-
-  it("warns without onError when setup throws, and keeps other plugins", async () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const { configurePlugins } = await importHost();
-    const healthy = capture("healthy");
-
-    configurePlugins(
-      [
-        {
-          id: "broken",
-          setup: () => {
-            throw new Error("setup failed");
-          },
-        },
-        healthy.plugin,
-      ],
-      { baseURL: "https://updates.example.com" },
-    );
-
-    expect(healthy.setup).toHaveBeenCalledOnce();
-    expect(warn).toHaveBeenCalledWith(
-      '[HotUpdater] Plugin "broken" failed in setup',
-      expect.objectContaining({ message: "setup failed" }),
-    );
-  });
-
-  it("never waits for a hook", async () => {
-    const { configurePlugins, emitPluginHook } = await importHost();
-    const onUpdateCheck = vi.fn(() => new Promise<void>(() => {}));
-    configurePlugins([{ id: "slow", setup: () => ({ onUpdateCheck }) }], {
-      baseURL: "https://updates.example.com",
-    });
-
-    const result = emitPluginHook("onUpdateCheck", () => ({
-      status: "UNCHANGED",
-      channel: "production",
-      bundleId: "bundle-id",
-      releaseId: null,
-      previousReleaseId: null,
-    }));
-
-    expect(result).toBeUndefined();
-    expect(onUpdateCheck).toHaveBeenCalledOnce();
-  });
-
-  it("builds an event only when a plugin listens", async () => {
-    const { configurePlugins, emitPluginHook } = await importHost();
-    configurePlugins([capture().plugin], {
-      baseURL: "https://updates.example.com",
-    });
-    const createPayload = vi.fn(() => null);
-
-    emitPluginHook("onUpdateError", createPayload);
-
-    expect(createPayload).not.toHaveBeenCalled();
-  });
-
-  it("exposes the app's identity and environment", async () => {
-    vi.stubGlobal("__DEV__", true);
-    vi.spyOn(Date, "now").mockReturnValue(1_700_000_000_000);
-    const { configurePlugins } = await importHost();
-    const plugin = capture();
-    configurePlugins([plugin.plugin], {
-      baseURL: "https://updates.example.com",
-    });
-    const context = plugin.context();
-
-    expect({
-      appVersion: context.appVersion,
-      bundleId: context.getBundleId(),
-      channel: context.getChannel(),
-      cohort: context.getCohort(),
-      fingerprintHash: context.getFingerprintHash(),
-      installId: context.installId,
-      isDebugBuild: context.isDebugBuild,
-      now: context.now(),
-      platform: context.platform,
-      sdkVersion: context.sdkVersion,
-    }).toEqual({
-      appVersion: "1.2.3",
-      bundleId: "bundle-id",
-      channel: "production",
-      cohort: "123",
-      fingerprintHash: null,
-      installId: "install-id",
-      isDebugBuild: true,
-      now: 1_700_000_000_000,
-      platform: "android",
-      sdkVersion: "test-sdk-version",
-    });
-  });
-
-  describe("fetch", () => {
-    it("requests a path under the resolved baseURL with the SDK's headers", async () => {
-      const fetchMock = vi.fn<typeof fetch>(
-        async () => new Response(null, { status: 204 }),
-      );
-      vi.stubGlobal("fetch", fetchMock);
-      const { configurePlugins } = await importHost();
-      const plugin = capture();
-      configurePlugins([plugin.plugin], {
-        baseURL: async () => "https://updates.example.com/hot-updater/",
-        requestHeaders: { "x-api-key": "client-key", "X-Shared": "sdk" },
-      });
-
-      await plugin.context().fetch("/events", {
-        headers: { "Content-Type": "application/json", "X-Shared": "plugin" },
-        method: "POST",
-      });
-
-      const [url, init] = fetchMock.mock.calls[0]!;
-      expect(url).toBe("https://updates.example.com/hot-updater/events");
-      expect(init?.method).toBe("POST");
-      const headers = new Headers(init?.headers);
-      expect(headers.get("x-api-key")).toBe("client-key");
-      expect(headers.get("content-type")).toBe("application/json");
-      expect(headers.get("x-shared")).toBe("plugin");
-    });
-
-    it("rejects with Request timed out after the SDK's timeout", async () => {
-      vi.useFakeTimers();
-      vi.stubGlobal(
-        "fetch",
-        vi.fn(
-          (_input: unknown, init?: RequestInit) =>
-            new Promise((_resolve, reject) => {
-              init?.signal?.addEventListener("abort", () => {
-                reject(
-                  Object.assign(new Error("aborted"), { name: "AbortError" }),
-                );
-              });
-            }),
-        ),
-      );
-      const { configurePlugins } = await importHost();
-      const plugin = capture();
-      configurePlugins([plugin.plugin], {
-        baseURL: "https://updates.example.com",
-        requestTimeout: 2_000,
-      });
-
-      const request = plugin.context().fetch("events");
-      const settled = expect(request).rejects.toThrow("Request timed out");
-      await vi.advanceTimersByTimeAsync(2_000);
-      await settled;
-    });
-
-    it("refuses a URL outside baseURL", async () => {
-      const { configurePlugins } = await importHost();
-      const plugin = capture();
-      configurePlugins([plugin.plugin], {
-        baseURL: "https://updates.example.com",
-      });
-
-      await expect(
-        plugin.context().fetch("https://elsewhere.example.com/events"),
-      ).rejects.toThrow("relative to baseURL");
-    });
-  });
-
-  describe("storage", () => {
-    it("scopes keys to the plugin and reads its own writes", async () => {
-      mocks.getStorageItem.mockReturnValue("from-native");
-      const { configurePlugins } = await importHost();
-      const plugin = capture("example");
-      configurePlugins([plugin.plugin], {
-        baseURL: "https://updates.example.com",
-      });
-      const { storage } = plugin.context();
-
-      expect(storage.get("state")).toBe("from-native");
-      expect(storage.get("state")).toBe("from-native");
-      storage.set("state", "next");
-      expect(storage.get("state")).toBe("next");
-      storage.set("state", null);
-      expect(storage.get("state")).toBeNull();
-
-      expect(mocks.getStorageItem).toHaveBeenCalledOnce();
-      expect(mocks.getStorageItem).toHaveBeenCalledWith(
-        "plugins/example/state",
-      );
-      expect(mocks.setStorageItem.mock.calls).toEqual([
-        ["plugins/example/state", "next"],
-        ["plugins/example/state", null],
-      ]);
-    });
-
-    it("refuses empty keys, non-string values, and values over 64 KB", async () => {
-      const { configurePlugins } = await importHost();
-      const plugin = capture();
-      configurePlugins([plugin.plugin], {
-        baseURL: "https://updates.example.com",
-      });
-      const { storage } = plugin.context();
-
-      expect(() => storage.get("")).toThrow("non-empty strings");
-      expect(() => storage.set("key", 1 as unknown as string)).toThrow(
-        "strings or null",
-      );
-      expect(() => storage.set("key", "x".repeat(64 * 1024 + 1))).toThrow(
-        "at most 64 KB",
-      );
-      expect(mocks.setStorageItem).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/plugins/insights/eventId.spec.ts

@@ -1,60 +0,0 @@
-import { createHash } from "node:crypto";
-
-import { isUUIDv7 } from "@hot-updater/core";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { createKeyedUUIDv7, createUUIDv7, sha256 } from "./eventId";
-
-describe("createUUIDv7", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.unstubAllGlobals();
-  });
-
-  it.each([
-    { label: "Web Crypto", crypto: globalThis.crypto },
-    { label: "no Web Crypto, as in React Native", crypto: undefined },
-  ])("leads with the 48-bit millisecond time using $label", ({ crypto }) => {
-    vi.useFakeTimers({ now: 0x0192_3456_789a });
-    vi.stubGlobal("crypto", crypto);
-
-    const id = createUUIDv7();
-
-    expect(isUUIDv7(id)).toBe(true);
-    expect(id.startsWith("01923456-789a-7")).toBe(true);
-    expect(createUUIDv7()).not.toBe(id);
-  });
-});
-
-describe("sha256", () => {
-  it.each([
-    "",
-    "abc",
-    "a".repeat(55),
-    "a".repeat(56),
-    "a".repeat(64),
-    "a".repeat(1_000),
-    "install-id\n2026-09-30\ndownload hash_mismatch bundle-id",
-    "한글 및 이모지 😀",
-  ])("matches Node's SHA-256 for %j", (value) => {
-    expect(Buffer.from(sha256(value)).toString("hex")).toBe(
-      createHash("sha256").update(value, "utf8").digest("hex"),
-    );
-  });
-});
-
-describe("createKeyedUUIDv7", () => {
-  it("gives one UUIDv7 per key and time, led by that time", () => {
-    const midnight = Date.UTC(2026, 8, 30);
-
-    const id = createKeyedUUIDv7("install-id\nfailure", midnight);
-
-    expect(isUUIDv7(id)).toBe(true);
-    expect(parseInt(id.replace(/-/g, "").slice(0, 12), 16)).toBe(midnight);
-    expect(createKeyedUUIDv7("install-id\nfailure", midnight)).toBe(id);
-    expect(createKeyedUUIDv7("install-id\nother", midnight)).not.toBe(id);
-    expect(
-      createKeyedUUIDv7("install-id\nfailure", midnight + 86_400_000),
-    ).not.toBe(id);
-  });
-});

package/src/plugins/insights/eventId.ts

@@ -1,171 +0,0 @@
-type RandomValuesSource = {
-  readonly getRandomValues?: (array: Uint8Array) => Uint8Array;
-};
-
-const formatUUIDv7 = (bytes: Uint8Array, timestamp: number): string => {
-  // Division, not bit shifts: shifts truncate to 32 bits, and a millisecond
-  // timestamp already needs 41.
-  let time = timestamp;
-  for (let index = 5; index >= 0; index -= 1) {
-    bytes[index] = time % 256;
-    time = Math.floor(time / 256);
-  }
-  bytes[6] = 0x70 | (bytes[6]! & 0x0f);
-  bytes[8] = 0x80 | (bytes[8]! & 0x3f);
-
-  const hex = Array.from(bytes, (byte) =>
-    byte.toString(16).padStart(2, "0"),
-  ).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-};
-
-/**
- * Creates an RFC 9562 UUIDv7: a 48-bit millisecond timestamp, then random bits.
- *
- * `createUUIDv7` from `@hot-updater/plugin-core` calls `crypto.getRandomValues`
- * unconditionally, but React Native has no Web Crypto unless the app installs a
- * polyfill. An Insights event ID only has to tell one event from another so a
- * retried POST is counted once, so `Math.random` is enough without one.
- */
-export const createUUIDv7 = (): string => {
-  const bytes = new Uint8Array(16);
-  const { crypto } = globalThis as { crypto?: RandomValuesSource };
-  if (typeof crypto?.getRandomValues === "function") {
-    crypto.getRandomValues(bytes);
-  } else {
-    for (let index = 0; index < bytes.length; index += 1) {
-      bytes[index] = Math.floor(Math.random() * 256);
-    }
-  }
-  return formatUUIDv7(bytes, Date.now());
-};
-
-const SHA256_K = [
-  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
-  0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
-  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
-  0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
-  0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
-  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
-  0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
-  0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
-  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-];
-
-const encodeUtf8 = (value: string): number[] => {
-  const bytes: number[] = [];
-  for (const character of value) {
-    const code = character.codePointAt(0)!;
-    if (code < 0x80) {
-      bytes.push(code);
-    } else if (code < 0x800) {
-      bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
-    } else if (code < 0x10000) {
-      bytes.push(
-        0xe0 | (code >> 12),
-        0x80 | ((code >> 6) & 0x3f),
-        0x80 | (code & 0x3f),
-      );
-    } else {
-      bytes.push(
-        0xf0 | (code >> 18),
-        0x80 | ((code >> 12) & 0x3f),
-        0x80 | ((code >> 6) & 0x3f),
-        0x80 | (code & 0x3f),
-      );
-    }
-  }
-  return bytes;
-};
-
-/** SHA-256 of a string's UTF-8 bytes, since React Native has no Web Crypto. */
-export const sha256 = (value: string): Uint8Array => {
-  const bytes = encodeUtf8(value);
-  const bitLength = bytes.length * 8;
-  bytes.push(0x80);
-  while (bytes.length % 64 !== 56) bytes.push(0);
-  for (let shift = 56; shift >= 0; shift -= 8) {
-    // The length's high word, as division, since shifts truncate to 32 bits.
-    bytes.push(
-      shift >= 32
-        ? Math.floor(bitLength / 2 ** shift) & 0xff
-        : (bitLength >>> shift) & 0xff,
-    );
-  }
-
-  const hash = [
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
-    0x1f83d9ab, 0x5be0cd19,
-  ];
-  const words: number[] = Array.from({ length: 64 }, () => 0);
-  const rotate = (word: number, bits: number) =>
-    (word >>> bits) | (word << (32 - bits));
-
-  for (let offset = 0; offset < bytes.length; offset += 64) {
-    for (let index = 0; index < 16; index += 1) {
-      const at = offset + index * 4;
-      words[index] =
-        (bytes[at]! << 24) |
-        (bytes[at + 1]! << 16) |
-        (bytes[at + 2]! << 8) |
-        bytes[at + 3]!;
-    }
-    for (let index = 16; index < 64; index += 1) {
-      const low = words[index - 15]!;
-      const high = words[index - 2]!;
-      const s0 = rotate(low, 7) ^ rotate(low, 18) ^ (low >>> 3);
-      const s1 = rotate(high, 17) ^ rotate(high, 19) ^ (high >>> 10);
-      words[index] = (words[index - 16]! + s0 + words[index - 7]! + s1) | 0;
-    }
-
-    let [a, b, c, d, e, f, g, h] = hash as [
-      number,
-      number,
-      number,
-      number,
-      number,
-      number,
-      number,
-      number,
-    ];
-    for (let index = 0; index < 64; index += 1) {
-      const s1 = rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25);
-      const choose = (e & f) ^ (~e & g);
-      const temp1 = (h + s1 + choose + SHA256_K[index]! + words[index]!) | 0;
-      const s0 = rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22);
-      const majority = (a & b) ^ (a & c) ^ (b & c);
-      const temp2 = (s0 + majority) | 0;
-      h = g;
-      g = f;
-      f = e;
-      e = (d + temp1) | 0;
-      d = c;
-      c = b;
-      b = a;
-      a = (temp1 + temp2) | 0;
-    }
-    const results = [a, b, c, d, e, f, g, h];
-    for (let index = 0; index < 8; index += 1) {
-      hash[index] = (hash[index]! + results[index]!) | 0;
-    }
-  }
-
-  const digest = new Uint8Array(32);
-  hash.forEach((word, index) => {
-    digest[index * 4] = (word >>> 24) & 0xff;
-    digest[index * 4 + 1] = (word >>> 16) & 0xff;
-    digest[index * 4 + 2] = (word >>> 8) & 0xff;
-    digest[index * 4 + 3] = word & 0xff;
-  });
-  return digest;
-};
-
-/**
- * A UUIDv7 derived from a key: its time field is `timestamp` and its random
- * bits are the key's SHA-256, so the same key and time always give the same
- * id, and a server that stores reports by id counts it once.
- */
-export const createKeyedUUIDv7 = (key: string, timestamp: number): string =>
-  formatUUIDv7(sha256(key).slice(0, 16), timestamp);