@hot-updater/react-native 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "React Native OTA solution for self-hosted",
   "source": "./src/index.ts",
   "main": "./lib/commonjs/index.js",
@@ -124,9 +124,9 @@
   },
   "dependencies": {
     "use-sync-external-store": "1.5.0",
-    "@hot-updater/protocol": "1.1.1",
-    "@hot-updater/plugin-remote-config": "1.1.1",
-    "@hot-updater/plugin-insights": "1.1.1"
+    "@hot-updater/protocol": "1.1.2",
+    "@hot-updater/plugin-remote-config": "1.1.2",
+    "@hot-updater/plugin-insights": "1.1.2"
   },
   "scripts": {
     "build": "node ./scripts/sync-sdk-version.mjs run -- bob build",

package/src/checkForUpdate.ts

@@ -37,6 +37,7 @@ import {
   stageBundle,
   supportsArtifactFiles,
 } from "./native";
+import { saveRecoveryCheckConfig } from "./recoveryCheckConfig";
 import { hotUpdaterStore } from "./store";
 import { classifyUpdateError, InvalidUpdateResponseError } from "./updateError";
 
@@ -214,9 +215,17 @@ async function checkForReleaseCatalogUpdate(input: {
     requestTimeout: options.requestTimeout,
     updateStrategy: options.updateStrategy,
   });
+  if (catalog !== null) validateCatalog(catalog, expectedScope);
+  // The server answered with a valid catalog, or with none yet: only such a
+  // request replaces the saved one, so one that fails keeps the last.
+  saveRecoveryCheckConfig({
+    baseURL: session.baseURL,
+    requestHeaders: options.requestHeaders,
+    requestTimeout: options.requestTimeout,
+    updateStrategy: options.updateStrategy,
+  });
   // The server says this scope has no catalog yet: no update, not a failure.
   if (catalog === null) return null;
-  validateCatalog(catalog, expectedScope);
   const catalogId = catalog.catalogId;
   const scopeKey = catalog.scopeKey;
 

package/src/httpClient.ts

@@ -59,6 +59,8 @@ export type ResolvedArtifact =
     };
 
 export interface HotUpdaterHttpSession {
+  /** The server this session requests, with a baseURL function resolved. */
+  readonly baseURL: string;
   /** Resolves to null when the server says the scope has no catalog, so no update. */
   fetchReleaseCatalog: (
     params: ReleaseCatalogRequest,
@@ -143,6 +145,7 @@ const createSession = (
   baseURL: string,
   onResponse?: (response: UpdateHttpResponse) => void,
 ): HotUpdaterHttpSession => ({
+  baseURL,
   fetchReleaseCatalog: async (params): Promise<ReleaseCatalog | null> => {
     const channelKey = encodeChannelKey(params.channel);
     let strategyValue: string;

package/src/recoveryCheckConfig.ts

@@ -0,0 +1,68 @@
+import type { CheckForUpdateOptions } from "./checkForUpdate";
+import { DEFAULT_REQUEST_TIMEOUT_MS } from "./fetchUpdateResponse";
+import { setStorageItem } from "./native";
+
+/**
+ * The native key-value entry native reads after a crash: once a launch of the
+ * app ends in a crash that doesn't roll back, the next launch checks for an
+ * update natively, without the app's JavaScript, whose own update flow may be
+ * what crashes. Native knows no server of its own, so the app's update checks
+ * leave it here. A device that never checked, such as one whose user hasn't
+ * accepted the privacy terms yet, has none, so native sends no request.
+ */
+export const RECOVERY_CHECK_CONFIG_KEY = "hot-updater/recovery-check-config";
+
+/** What native reads; native rejects any other `version`. */
+interface RecoveryCheckConfig {
+  readonly version: 1;
+  readonly baseURL: string;
+  readonly requestHeaders: Record<string, string>;
+  readonly requestTimeoutMs: number;
+  readonly updateStrategy: CheckForUpdateOptions["updateStrategy"];
+}
+
+const write = (config: RecoveryCheckConfig) => {
+  // An update check never fails because native couldn't keep this.
+  try {
+    setStorageItem(RECOVERY_CHECK_CONFIG_KEY, JSON.stringify(config));
+  } catch (error) {
+    console.warn(
+      "[HotUpdater] Failed to save the recovery check config",
+      error,
+    );
+  }
+};
+
+/**
+ * The headers as the request sent them: `Headers` lowercases names and
+ * joins two spellings of one name, as the catalog request did, so native
+ * repeats the same values instead of picking one of the spellings.
+ */
+const sentHeaders = (headers: Record<string, string> | undefined) =>
+  Object.fromEntries(new Headers(headers).entries());
+
+/**
+ * Saves the request of an update check the server answered: the server it
+ * resolved, its headers and timeout, and its update strategy, which only a
+ * check knows. Only answered checks save it, so native always repeats a
+ * request that reached the server, whichever instance made it last, and a
+ * device that never checked sends nothing. Native checks of main save theirs
+ * the same way. The channel is left out on purpose: native checks
+ * the device's own channel, the one the crashing bundle came from and its fix
+ * is published to. A check of another channel is a one-off until its update
+ * is applied, and a crash must not switch the device's channel.
+ */
+export const saveRecoveryCheckConfig = (input: {
+  readonly baseURL: string;
+  readonly requestHeaders?: Record<string, string>;
+  readonly requestTimeout?: number;
+  readonly updateStrategy: CheckForUpdateOptions["updateStrategy"];
+}) => {
+  write({
+    version: 1,
+    baseURL: input.baseURL,
+    requestHeaders: sentHeaders(input.requestHeaders),
+    requestTimeoutMs: input.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS,
+    updateStrategy: input.updateStrategy,
+  });
+};

package/src/sdkVersion.ts

@@ -1 +1 @@
-export const HOT_UPDATER_SDK_VERSION = "1.1.1";
+export const HOT_UPDATER_SDK_VERSION = "1.1.2";