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

package/src/pluginHost.ts

@@ -1,12 +1,6 @@
+import { createPluginHost } from "@hot-updater/protocol";
 import { Platform } from "react-native";
 
-import { resolveBaseURL } from "./baseURL";
-import type {
-  HotUpdaterClientContext,
-  HotUpdaterClientHooks,
-  HotUpdaterClientPlugin,
-  HotUpdaterClientStorage,
-} from "./clientPlugin";
 import {
   getAppVersion,
   getBundleId,
@@ -18,245 +12,34 @@ import {
   setStorageItem,
 } from "./native";
 import { HOT_UPDATER_SDK_VERSION } from "./sdkVersion";
-import type { HotUpdaterBaseURL } from "./types";
 
-type HookName = keyof HotUpdaterClientHooks;
-type HookPayload<K extends HookName> = Parameters<
-  NonNullable<HotUpdaterClientHooks[K]>
->[0];
-
-/** The init or wrap settings plugins see through their context. */
-export interface PluginHostConfig {
-  readonly baseURL: HotUpdaterBaseURL;
-  readonly requestHeaders?: Record<string, string>;
-  readonly requestTimeout?: number;
-  readonly onError?: (error: unknown) => void;
-}
-
-/** Storage values stay small, since native reads them on the JS thread. */
-const MAX_STORAGE_VALUE_LENGTH = 64 * 1024;
-
-let config: PluginHostConfig | null = null;
-/** Hooks by plugin, so a plugin configured again is not set up twice. */
-const setUpPlugins = new WeakMap<
-  HotUpdaterClientPlugin,
-  HotUpdaterClientHooks
->();
-let activePlugins: readonly {
-  readonly plugin: HotUpdaterClientPlugin;
-  readonly hooks: HotUpdaterClientHooks;
-}[] = [];
-/** What plugins read and wrote, so a read follows a write before native does. */
-const storageValues = new Map<string, string | null>();
-
-const reportHookError = (message: string, error: unknown) => {
-  const report = new Error(`[HotUpdater] ${message}`, { cause: error });
-  try {
-    if (config?.onError) {
-      config.onError(report);
-      return;
-    }
-  } catch {
-    // A throwing onError must not break the update path either.
-  }
-  console.warn(report.message, error);
-};
-
-const fetchFromServer = async (
-  path: string,
-  init: RequestInit = {},
-): Promise<Response> => {
-  if (config === null) {
-    throw new Error("[HotUpdater] Plugins can fetch only after init or wrap.");
-  }
-  if (/^[a-z][a-z\d+.-]*:/i.test(path) || path.startsWith("//")) {
-    throw new TypeError(
-      "[HotUpdater] Plugin fetch takes a path relative to baseURL.",
-    );
-  }
-  const { requestHeaders, requestTimeout } = config;
-  const url = `${await resolveBaseURL(config.baseURL)}/${path.replace(/^\/+/, "")}`;
-  const headers = new Headers(requestHeaders);
-  new Headers(init.headers).forEach((value, name) => {
-    headers.set(name, value);
-  });
-
-  const controller = new AbortController();
-  const callerSignal = init.signal;
-  const abortFromCaller = () => controller.abort();
-  if (callerSignal?.aborted) controller.abort();
-  callerSignal?.addEventListener("abort", abortFromCaller);
-  const timeoutId = setTimeout(
-    () => controller.abort(),
-    requestTimeout ?? 5000,
-  );
-
-  try {
-    return await fetch(url, { ...init, headers, signal: controller.signal });
-  } catch (error: unknown) {
-    if (
-      error instanceof Error &&
-      error.name === "AbortError" &&
-      !callerSignal?.aborted
-    ) {
-      throw new Error("Request timed out");
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
-    callerSignal?.removeEventListener("abort", abortFromCaller);
-  }
-};
-
-const createStorage = (pluginId: string): HotUpdaterClientStorage => {
-  const scopedKey = (key: string) => {
-    if (typeof key !== "string" || key.length === 0) {
-      throw new TypeError(
-        "[HotUpdater] Plugin storage keys are non-empty strings.",
-      );
-    }
-    // Encoded, so no id and key pair can name another plugin's key.
-    return `plugins/${encodeURIComponent(pluginId)}/${key}`;
-  };
-
-  return {
-    get: (key) => {
-      const storageKey = scopedKey(key);
-      const cached = storageValues.get(storageKey);
-      if (cached !== undefined) return cached;
-      const value = getStorageItem(storageKey);
-      storageValues.set(storageKey, value);
-      return value;
-    },
-    set: (key, value) => {
-      const storageKey = scopedKey(key);
-      if (value !== null && typeof value !== "string") {
-        throw new TypeError(
-          "[HotUpdater] Plugin storage values are strings or null.",
-        );
-      }
-      if (value !== null && value.length > MAX_STORAGE_VALUE_LENGTH) {
-        throw new RangeError(
-          "[HotUpdater] Plugin storage values are at most 64 KB.",
-        );
-      }
-      setStorageItem(storageKey, value);
-      storageValues.set(storageKey, value);
-    },
-  };
-};
-
-const createContext = (pluginId: string): HotUpdaterClientContext => ({
-  fetch: fetchFromServer,
-  get installId() {
-    return getInstallId();
+export type { PluginHostConfig } from "@hot-updater/protocol";
+
+/** The app's plugin host: plugins read the native module and fetch the configured server. */
+export const {
+  configurePlugins,
+  hasPluginHook,
+  buildPluginEvent,
+  dispatchPluginHook,
+  emitPluginHook,
+} = createPluginHost({
+  fetch: (url, init) => fetch(url, init),
+  get platform() {
+    return Platform.OS === "android" ? "android" : "ios";
   },
-  platform: Platform.OS === "android" ? "android" : "ios",
-  get appVersion() {
-    return getAppVersion();
+  get isDebugBuild() {
+    return typeof __DEV__ !== "undefined" && __DEV__;
   },
   get sdkVersion() {
     return HOT_UPDATER_SDK_VERSION;
   },
-  isDebugBuild: typeof __DEV__ !== "undefined" && __DEV__,
-  getBundleId,
-  getChannel,
-  getCohort,
-  getFingerprintHash,
-  storage: createStorage(pluginId),
+  getInstallId: () => getInstallId(),
+  getAppVersion: () => getAppVersion(),
+  getBundleId: () => getBundleId(),
+  getChannel: () => getChannel(),
+  getCohort: () => getCohort(),
+  getFingerprintHash: () => getFingerprintHash(),
+  getStorageItem: (key) => getStorageItem(key),
+  setStorageItem: (key, value) => setStorageItem(key, value),
   now: () => Date.now(),
 });
-
-/**
- * Sets up the plugins of an init or wrap call. A plugin passed to an earlier
- * call keeps its hooks, and a plugin left out stops receiving events.
- */
-export const configurePlugins = (
-  plugins: readonly HotUpdaterClientPlugin[] | undefined,
-  nextConfig: PluginHostConfig,
-): void => {
-  const ids = new Set<string>();
-  for (const plugin of plugins ?? []) {
-    if (typeof plugin.id !== "string" || plugin.id.length === 0) {
-      throw new Error("[HotUpdater] A plugin id must be a non-empty string.");
-    }
-    if (ids.has(plugin.id)) {
-      throw new Error(
-        `[HotUpdater] Two plugins use the id "${plugin.id}". Plugin ids must be unique.`,
-      );
-    }
-    ids.add(plugin.id);
-  }
-
-  config = nextConfig;
-  activePlugins = (plugins ?? []).map((plugin) => {
-    let hooks = setUpPlugins.get(plugin);
-    if (hooks === undefined) {
-      try {
-        hooks = plugin.setup(createContext(plugin.id)) ?? {};
-      } catch (error) {
-        reportHookError(`Plugin "${plugin.id}" failed in setup`, error);
-        hooks = {};
-      }
-      setUpPlugins.set(plugin, hooks);
-    }
-    return { plugin, hooks };
-  });
-};
-
-/** Whether any plugin listens to this hook, so callers build events only when one does. */
-export const hasPluginHook = (name: HookName): boolean =>
-  activePlugins.some(({ hooks }) => typeof hooks[name] === "function");
-
-/**
- * Builds a hook's event when a plugin listens. A failure to build it is
- * reported, not thrown, since reporting never changes an update.
- */
-export const buildPluginEvent = <K extends HookName>(
-  name: K,
-  createPayload: () => HookPayload<K> | null,
-): HookPayload<K> | null => {
-  if (!hasPluginHook(name)) return null;
-  try {
-    return createPayload();
-  } catch (error) {
-    reportHookError(`Failed to build the ${name} event for plugins`, error);
-    return null;
-  }
-};
-
-/** Calls a hook on every plugin that listens, without waiting for any. */
-export const dispatchPluginHook = <K extends HookName>(
-  name: K,
-  payload: HookPayload<K>,
-): void => {
-  for (const { plugin, hooks } of activePlugins) {
-    const hook = hooks[name] as
-      | ((payload: HookPayload<K>) => unknown)
-      | undefined;
-    if (typeof hook !== "function") continue;
-    try {
-      const result = hook.call(hooks, payload);
-      if (
-        result !== null &&
-        typeof result === "object" &&
-        typeof (result as PromiseLike<unknown>).then === "function"
-      ) {
-        void Promise.resolve(result).catch((error: unknown) => {
-          reportHookError(`Plugin "${plugin.id}" failed in ${name}`, error);
-        });
-      }
-    } catch (error) {
-      reportHookError(`Plugin "${plugin.id}" failed in ${name}`, error);
-    }
-  }
-};
-
-/** Builds a hook's event when a plugin listens and calls the hook right away. */
-export const emitPluginHook = <K extends HookName>(
-  name: K,
-  createPayload: () => HookPayload<K> | null,
-): void => {
-  const payload = buildPluginEvent(name, createPayload);
-  if (payload !== null) dispatchPluginHook(name, payload);
-};

package/src/releaseCatalogCache.ts

@@ -1,19 +1,15 @@
 import {
-  MAX_TARGET_COHORTS_PER_RELEASE,
-  MAX_COMPILED_CATALOG_BYTES,
-  MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE,
-  NUMERIC_COHORT_SIZE,
-  isUUIDv7,
-  parseReleaseCatalogScopeKey,
+  type ExpectedReleaseCatalogScope,
+  getUtf8ByteLength,
+  MAX_RELEASE_CATALOG_WIRE_BYTES,
+  parseReleaseCatalog,
   type ReleaseCatalog,
-} from "@hot-updater/core";
+} from "@hot-updater/protocol";
 
 import { InvalidUpdateResponseError, UpdateHttpError } from "./updateError";
 
 const CACHE_FORMAT_VERSION = "1";
 const MAX_ETAG_BYTES = 1024;
-export const MAX_RELEASE_CATALOG_WIRE_BYTES =
-  MAX_COMPILED_CATALOG_BYTES * 2 + 4 * 1024;
 export const MAX_RELEASE_CATALOG_CACHE_ENTRY_BYTES =
   MAX_RELEASE_CATALOG_WIRE_BYTES + MAX_ETAG_BYTES + 3;
 
@@ -48,20 +44,6 @@ let lastParsedCache:
     })
   | null = null;
 
-export type ExpectedReleaseCatalogScope = {
-  readonly channelKey: string;
-  readonly platform: "ios" | "android";
-} & (
-  | {
-      readonly strategy: "APP_VERSION";
-      readonly fingerprintHash?: never;
-    }
-  | {
-      readonly strategy: "FINGERPRINT";
-      readonly fingerprintHash: string;
-    }
-);
-
 type FetchReleaseCatalogInput = {
   readonly baseURL: string;
   readonly expectedScope: ExpectedReleaseCatalogScope;
@@ -70,117 +52,6 @@ type FetchReleaseCatalogInput = {
   readonly url: string;
 };
 
-const getUtf8ByteLength = (value: string): number => {
-  let bytes = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code <= 0x7f) {
-      bytes += 1;
-    } else if (code <= 0x7ff) {
-      bytes += 2;
-    } else if (
-      code >= 0xd800 &&
-      code <= 0xdbff &&
-      index + 1 < value.length &&
-      value.charCodeAt(index + 1) >= 0xdc00 &&
-      value.charCodeAt(index + 1) <= 0xdfff
-    ) {
-      bytes += 4;
-      index += 1;
-    } else {
-      bytes += 3;
-    }
-  }
-  return bytes;
-};
-
-const isStringArray = (value: unknown): value is readonly string[] =>
-  Array.isArray(value) && value.every((entry) => typeof entry === "string");
-
-const isValidReleaseDescriptor = (value: unknown): boolean => {
-  if (value === null || typeof value !== "object") return false;
-  const descriptor = value as Record<string, unknown>;
-
-  return (
-    isUUIDv7(descriptor.releaseId) &&
-    (descriptor.kind === "BUNDLE" || descriptor.kind === "EMBEDDED") &&
-    ((descriptor.kind === "BUNDLE" &&
-      typeof descriptor.bundleId === "string") ||
-      (descriptor.kind === "EMBEDDED" && descriptor.bundleId === null)) &&
-    Number.isSafeInteger(descriptor.rolloutCohortCount) &&
-    (descriptor.rolloutCohortCount as number) >= 0 &&
-    (descriptor.rolloutCohortCount as number) <= NUMERIC_COHORT_SIZE &&
-    isStringArray(descriptor.targetCohorts) &&
-    descriptor.targetCohorts.length <= MAX_TARGET_COHORTS_PER_RELEASE &&
-    typeof descriptor.shouldForceUpdate === "boolean" &&
-    (descriptor.message === null || typeof descriptor.message === "string")
-  );
-};
-
-export const hasExpectedReleaseCatalogScope = (
-  catalog: ReleaseCatalog,
-  expected: ExpectedReleaseCatalogScope,
-): boolean => {
-  try {
-    const parsed = parseReleaseCatalogScopeKey(catalog.scopeKey);
-    return (
-      parsed.channelKey === expected.channelKey &&
-      parsed.platform === expected.platform &&
-      parsed.strategy === expected.strategy &&
-      (parsed.strategy === "APP_VERSION" ||
-        (expected.strategy === "FINGERPRINT" &&
-          parsed.fingerprintHash === expected.fingerprintHash))
-    );
-  } catch {
-    return false;
-  }
-};
-
-const parseValidatedCatalog = (
-  value: string,
-  expectedScope: ExpectedReleaseCatalogScope,
-): ReleaseCatalog | null => {
-  if (getUtf8ByteLength(value) > MAX_RELEASE_CATALOG_WIRE_BYTES) return null;
-
-  try {
-    const catalog = JSON.parse(value) as Partial<ReleaseCatalog>;
-    if (
-      catalog.schemaVersion !== 1 ||
-      typeof catalog.catalogId !== "string" ||
-      catalog.catalogId.length === 0 ||
-      typeof catalog.scopeKey !== "string" ||
-      !Number.isSafeInteger(catalog.generation) ||
-      (catalog.generation ?? 0) < 1 ||
-      typeof catalog.catalogHash !== "string" ||
-      !/^sha256:[0-9a-f]{64}$/.test(catalog.catalogHash) ||
-      catalog.fallbackPolicy !== "BUILTIN_IF_ACTIVE_INELIGIBLE" ||
-      !Array.isArray(catalog.releases) ||
-      !catalog.releases.every(isValidReleaseDescriptor) ||
-      (catalog.rollbackReleases !== undefined &&
-        (!Array.isArray(catalog.rollbackReleases) ||
-          !catalog.rollbackReleases.every(isValidReleaseDescriptor)))
-    ) {
-      return null;
-    }
-    if (
-      !hasExpectedReleaseCatalogScope(catalog as ReleaseCatalog, expectedScope)
-    ) {
-      return null;
-    }
-    const distinctTargetCohorts = new Set(
-      [...catalog.releases, ...(catalog.rollbackReleases ?? [])].flatMap(
-        (release) => release.targetCohorts,
-      ),
-    );
-    if (distinctTargetCohorts.size > MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE) {
-      return null;
-    }
-    return catalog as ReleaseCatalog;
-  } catch {
-    return null;
-  }
-};
-
 const isValidETag = (value: string | null): value is string =>
   value !== null &&
   value.length > 0 &&
@@ -216,7 +87,7 @@ const parseCache = (
   const etag = value.slice(versionEnd + 1, etagEnd);
   const body = value.slice(etagEnd + 1);
   if (!isValidETag(etag)) return null;
-  const catalog = parseValidatedCatalog(body, expectedScope);
+  const catalog = parseReleaseCatalog(body, expectedScope);
   if (catalog === null) return null;
   const parsed = { catalog, etag, partition, serialized: value };
   lastParsedCache = parsed;
@@ -307,7 +178,7 @@ const consumeSuccessfulResponse = async (
   }
 
   const body = await response.text();
-  const catalog = parseValidatedCatalog(body, input.expectedScope);
+  const catalog = parseReleaseCatalog(body, input.expectedScope);
   if (catalog === null) {
     await removeNativeReleaseCatalogCache(partition);
     throw new InvalidUpdateResponseError("Received an invalid Release catalog");

package/src/sdkVersion.ts

@@ -1 +1 @@
-export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.17";
+export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.21";

package/src/types.ts

@@ -1,4 +1,4 @@
-export type HotUpdaterBaseURL = string | (() => string | Promise<string>);
+export type { HotUpdaterBaseURL } from "@hot-updater/protocol";
 
 /**
  * Information about a signature verification failure.

package/src/wrap.types.ts

@@ -29,8 +29,8 @@ export type HotUpdaterFallbackComponentProps = {
 
 interface CommonHotUpdaterOptions {
   /**
-   * Client plugins, such as `insights()` from
-   * `@hot-updater/react-native/plugins/insights`. Each plugin's `setup` runs
+   * Client plugins, such as `insights()` from `@hot-updater/react-native`.
+   * Each plugin's `setup` runs
    * once, and its hooks observe launches, update checks, downloads, and
    * update failures. Plugin ids must be unique.
    */

package/android/src/test/java/com/hotupdater/BsdiffPatchTest.kt

@@ -1,46 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertThrows
-import org.junit.Assert.assertTrue
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.util.Base64
-
-class BsdiffPatchTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `applies bsdiff patch and verifies patched output hash`() {
-        val base = "console.log(\"base bundle\");\n".toByteArray()
-        val expected = "console.log(\"patched bundle\");\n".toByteArray()
-        val patch = Base64.getDecoder().decode(BSDIFF_PATCH_FIXTURE_BASE64)
-        val baseFile = temporaryFolder.newFile("base.bundle").apply { writeBytes(base) }
-        val patchFile = temporaryFolder.newFile("patch.bsdiff").apply { writeBytes(patch) }
-        val outputFile = temporaryFolder.newFile("output.bundle")
-
-        BsdiffPatch.apply(baseFile, patchFile, outputFile)
-
-        assertArrayEquals(expected, outputFile.readBytes())
-        assertTrue(HashUtils.verifyHash(outputFile, HashUtils.calculateSHA256(outputFile)))
-        assertFalse(HashUtils.verifyHash(outputFile, HashUtils.calculateSHA256(baseFile)))
-    }
-
-    @Test
-    fun `rejects invalid bsdiff patch`() {
-        val base = "console.log(\"base bundle\");\n".toByteArray()
-        val invalidPatch = "not-a-bsdiff-patch-with-header".toByteArray()
-
-        assertThrows(IllegalArgumentException::class.java) {
-            BsdiffPatch.apply(base, invalidPatch)
-        }
-    }
-
-    companion object {
-        const val BSDIFF_PATCH_FIXTURE_BASE64 =
-            "RU5EU0xFWS9CU0RJRkY0Mx8AAAAAAAAAQlpoOTFBWSZTWb12MIEAAAB5gEQYAADQYQAIPsXOACAAIo0A0NAaNCgAGgZMgHAtYscVxxRtTt4nmaj70g4gQSF5+T4u5IpwoSF67GEC"
-    }
-}