@hot-updater/react-native 0.30.10 → 0.30.12

package/src/DefaultResolver.spec.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createDefaultResolver } from "./DefaultResolver";
+import type { ResolverCheckUpdateParams } from "./types";
+
+const mocks = vi.hoisted(() => ({
+  fetchUpdateInfo: vi.fn(),
+}));
+
+vi.mock("./fetchUpdateInfo", () => ({
+  fetchUpdateInfo: mocks.fetchUpdateInfo,
+}));
+
+const createParams = (
+  params?: Partial<ResolverCheckUpdateParams>,
+): ResolverCheckUpdateParams => ({
+  appVersion: "1.0.0",
+  bundleId: "bundle-id",
+  channel: "production",
+  cohort: "cohort",
+  fingerprintHash: null,
+  minBundleId: "min-bundle-id",
+  platform: "ios",
+  updateStrategy: "appVersion",
+  ...params,
+});
+
+describe("createDefaultResolver", () => {
+  beforeEach(() => {
+    mocks.fetchUpdateInfo.mockReset();
+    mocks.fetchUpdateInfo.mockResolvedValue(null);
+  });
+
+  it("resolves dynamic baseURL before checking for updates", async () => {
+    const resolveBaseURL = vi.fn(async () => "https://updates.example.com");
+    const resolver = createDefaultResolver(resolveBaseURL);
+
+    await resolver.checkUpdate?.(createParams());
+
+    expect(resolveBaseURL).toHaveBeenCalledWith();
+    expect(mocks.fetchUpdateInfo).toHaveBeenCalledWith({
+      requestHeaders: undefined,
+      requestTimeout: undefined,
+      url: "https://updates.example.com/app-version/ios/1.0.0/production/min-bundle-id/bundle-id/cohort",
+    });
+  });
+
+  it("calls dynamic baseURL for each update check", async () => {
+    const resolveBaseURL = vi
+      .fn<() => Promise<string>>()
+      .mockResolvedValueOnce("https://one.example.com")
+      .mockResolvedValueOnce("https://two.example.com");
+    const resolver = createDefaultResolver(resolveBaseURL);
+
+    await resolver.checkUpdate?.(createParams());
+    await resolver.checkUpdate?.(createParams());
+
+    expect(resolveBaseURL).toHaveBeenCalledTimes(2);
+    expect(mocks.fetchUpdateInfo).toHaveBeenNthCalledWith(1, {
+      requestHeaders: undefined,
+      requestTimeout: undefined,
+      url: "https://one.example.com/app-version/ios/1.0.0/production/min-bundle-id/bundle-id/cohort",
+    });
+    expect(mocks.fetchUpdateInfo).toHaveBeenNthCalledWith(2, {
+      requestHeaders: undefined,
+      requestTimeout: undefined,
+      url: "https://two.example.com/app-version/ios/1.0.0/production/min-bundle-id/bundle-id/cohort",
+    });
+  });
+
+  it("rejects an empty dynamic baseURL", async () => {
+    const resolver = createDefaultResolver(() => "");
+
+    await expect(resolver.checkUpdate?.(createParams())).rejects.toThrow(
+      "baseURL resolver must return a non-empty string",
+    );
+  });
+});

package/src/DefaultResolver.ts

@@ -1,20 +1,39 @@
 import type { AppUpdateInfo } from "@hot-updater/core";
 
 import { fetchUpdateInfo } from "./fetchUpdateInfo";
-import type { HotUpdaterResolver, ResolverCheckUpdateParams } from "./types";
+import type {
+  HotUpdaterBaseURL,
+  HotUpdaterResolver,
+  ResolverCheckUpdateParams,
+} from "./types";
+
+const resolveBaseURL = async (baseURL: HotUpdaterBaseURL): Promise<string> => {
+  const resolvedBaseURL =
+    typeof baseURL === "function" ? await baseURL() : baseURL;
+
+  if (!resolvedBaseURL) {
+    throw new Error("baseURL resolver must return a non-empty string");
+  }
+
+  return resolvedBaseURL;
+};
 
 /**
  * Creates a default resolver that uses baseURL for network operations.
  * This encapsulates the existing baseURL logic into a resolver.
  *
- * @param baseURL - The base URL for the update server
+ * @param baseURL - The base URL for the update server, or a function that
+ * resolves it before each update check.
  * @returns A HotUpdaterResolver that uses the baseURL
  */
-export function createDefaultResolver(baseURL: string): HotUpdaterResolver {
+export function createDefaultResolver(
+  baseURL: HotUpdaterBaseURL,
+): HotUpdaterResolver {
   return {
     checkUpdate: async (
       params: ResolverCheckUpdateParams,
     ): Promise<AppUpdateInfo | null> => {
+      const resolvedBaseURL = await resolveBaseURL(baseURL);
       let url: string;
       const cohortPath = `/${encodeURIComponent(params.cohort)}`;
 
@@ -22,9 +41,9 @@ export function createDefaultResolver(baseURL: string): HotUpdaterResolver {
         if (!params.fingerprintHash) {
           throw new Error("Fingerprint hash is required");
         }
-        url = `${baseURL}/fingerprint/${params.platform}/${params.fingerprintHash}/${params.channel}/${params.minBundleId}/${params.bundleId}${cohortPath}`;
+        url = `${resolvedBaseURL}/fingerprint/${params.platform}/${params.fingerprintHash}/${params.channel}/${params.minBundleId}/${params.bundleId}${cohortPath}`;
       } else {
-        url = `${baseURL}/app-version/${params.platform}/${params.appVersion}/${params.channel}/${params.minBundleId}/${params.bundleId}${cohortPath}`;
+        url = `${resolvedBaseURL}/app-version/${params.platform}/${params.appVersion}/${params.channel}/${params.minBundleId}/${params.bundleId}${cohortPath}`;
       }
 
       return fetchUpdateInfo({

package/src/fetchUpdateInfo.ts

@@ -3,20 +3,18 @@ import type { AppUpdateInfo } from "@hot-updater/core";
 export const fetchUpdateInfo = async ({
   url,
   requestHeaders,
-  onError,
   requestTimeout = 5000,
 }: {
   url: string;
   requestHeaders?: Record<string, string>;
-  onError?: (error: Error) => void;
   requestTimeout?: number;
 }): Promise<AppUpdateInfo | null> => {
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-    }, requestTimeout);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, requestTimeout);
 
+  try {
     const headers = {
       "Content-Type": "application/json",
       ...requestHeaders,
@@ -26,7 +24,6 @@ export const fetchUpdateInfo = async ({
       signal: controller.signal,
       headers,
     });
-    clearTimeout(timeoutId);
 
     if (response.status !== 200) {
       throw new Error(response.statusText);
@@ -34,10 +31,10 @@ export const fetchUpdateInfo = async ({
     return response.json();
   } catch (error: unknown) {
     if (error instanceof Error && error.name === "AbortError") {
-      onError?.(new Error("Request timed out"));
-    } else {
-      onError?.(error as Error);
+      throw new Error("Request timed out");
     }
-    return null;
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
   }
 };

package/src/index.spec.ts

@@ -74,7 +74,7 @@ describe("HotUpdater client initialization", () => {
 
     mocks.addListener.mockReturnValue(() => {});
     mocks.checkForUpdate.mockResolvedValue(null);
-    mocks.createDefaultResolver.mockImplementation((baseURL: string) => ({
+    mocks.createDefaultResolver.mockImplementation((baseURL: unknown) => ({
       baseURL,
       checkUpdate: vi.fn(),
       notifyAppReady: vi.fn(),
@@ -114,6 +114,26 @@ describe("HotUpdater client initialization", () => {
     });
   });
 
+  it("accepts dynamic baseURL resolvers for manual update flows", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    const resolveBaseURL = vi.fn(() => "https://updates.example.com");
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({
+      baseURL: resolveBaseURL,
+    });
+
+    expect(mocks.createDefaultResolver).toHaveBeenCalledWith(resolveBaseURL);
+    expect(mocks.init).toHaveBeenCalledWith({
+      resolver,
+    });
+  });
+
   it("uses init configuration for later manual update checks", async () => {
     const resolver = {
       checkUpdate: vi.fn(),

package/src/index.ts

@@ -48,6 +48,7 @@ export type {
 export * from "./store";
 export {
   extractSignatureFailure,
+  type HotUpdaterBaseURL,
   type HotUpdaterResolver,
   isSignatureVerificationError,
   type ResolverCheckUpdateParams,

package/src/types.ts

@@ -2,6 +2,8 @@ import type { AppUpdateInfo } from "@hot-updater/core";
 
 import type { NotifyAppReadyResult } from "./native";
 
+export type HotUpdaterBaseURL = string | (() => string | Promise<string>);
+
 /**
  * Parameters passed to resolver.checkUpdate method
  */

package/src/wrap.tsx

@@ -10,7 +10,7 @@ import {
   reload,
 } from "./native";
 import { useHotUpdaterStore } from "./store";
-import type { HotUpdaterResolver } from "./types";
+import type { HotUpdaterBaseURL, HotUpdaterResolver } from "./types";
 
 export interface RunUpdateProcessResponse {
   status: "ROLLBACK" | "UPDATE" | "UP_TO_DATE";
@@ -70,10 +70,12 @@ interface CommonHotUpdaterOptions {
  */
 interface BaseURLConfig {
   /**
-   * Base URL for update server
+   * Base URL for update server. Use a function to resolve it dynamically
+   * before each update check.
    * @example "https://update.example.com"
+   * @example () => getUpdateServerURL()
    */
-  baseURL: string;
+  baseURL: HotUpdaterBaseURL;
 
   /**
    * Resolver is not allowed when using baseURL