react-native-instantpay-code-push 1.1.0

package/src/native.ts

@@ -0,0 +1,280 @@
+import { NativeEventEmitter } from "react-native";
+import { IpayCodePushErrorCode, isIpayCodePushError } from "./error";
+import type { UpdateStatus } from "./types"
+
+import IpayCodePushNative, {
+    type UpdateBundleParams
+} from './NativeInstantpayCodePush';
+
+
+export { IpayCodePushErrorCode, isIpayCodePushError };
+
+const NIL_UUID = "00000000-0000-0000-0000-000000000000";
+
+const __IPAY_CODE_PUSH_BUNDLE_ID=undefined;
+
+export const IpayCodePushConstants = {
+    IPAY_CODE_PUSH_BUNDLE_ID: __IPAY_CODE_PUSH_BUNDLE_ID || NIL_UUID,
+};
+
+export type IpayCodePushEvent = {
+    onProgress: {
+        progress: number;
+    };
+};
+
+
+export const addListener = <T extends keyof IpayCodePushEvent>(
+    eventName: T,
+    listener: (event: any) => void, //(event: IpayCodePushEvent[T])
+) => {
+    const eventEmitter = new NativeEventEmitter(IpayCodePushNative);
+    const subscription = eventEmitter.addListener(eventName, listener);
+
+    return () => {
+        subscription.remove();
+    };
+};
+
+export type UpdateParams = UpdateBundleParams & {
+    status: UpdateStatus;
+};
+
+// In-flight update deduplication by bundleId (session-scoped).
+const inflightUpdates = new Map<string, Promise<boolean>>();
+
+// Tracks the last successfully installed bundleId for this session.
+let lastInstalledBundleId: string | null = null;
+
+/**
+ * Downloads files and applies them to the app.
+ *
+ * @param {UpdateParams} params - Parameters object required for bundle update
+ * @returns {Promise<boolean>} Resolves with true if download was successful
+ * @throws {Error} Rejects with error.code from HotUpdaterErrorCode enum and error.message
+ */
+export async function updateBundle(params: UpdateParams): Promise<boolean>;
+
+/**
+ * @deprecated Use updateBundle(params: UpdateBundleParamsWithStatus) instead
+ */
+export async function updateBundle(
+    bundleId: string,
+    fileUrl: string | null,
+): Promise<boolean>;
+
+export async function updateBundle(
+    paramsOrBundleId: UpdateParams | string,
+    fileUrl?: string | null,
+): Promise<boolean> {
+
+    const updateBundleId = typeof paramsOrBundleId === "string" ? paramsOrBundleId : paramsOrBundleId.bundleId;
+
+    const status = typeof paramsOrBundleId === "string" ? "UPDATE" : paramsOrBundleId.status;
+
+    // If we have already installed this bundle in this session, skip re-download.
+    if (status === "UPDATE" && lastInstalledBundleId === updateBundleId) {
+        return true;
+    }
+
+    const currentBundleId = getBundleId();
+
+    // updateBundleId <= currentBundleId
+    if (
+        status === "UPDATE" &&
+        updateBundleId.localeCompare(currentBundleId) <= 0
+    ) {
+        throw new Error(
+            "Update bundle id is the same as the current bundle id. Preventing infinite update loop.",
+        );
+    }
+
+    // In-flight guard: return the same promise if the same bundle is already updating.
+    const existing = inflightUpdates.get(updateBundleId);
+    if (existing) return existing;
+
+    const targetFileUrl = typeof paramsOrBundleId === "string" ? (fileUrl ?? null) : paramsOrBundleId.fileUrl;
+
+    const targetFileHash = typeof paramsOrBundleId === "string" ? undefined : paramsOrBundleId.fileHash;
+
+    const promise = (async () => {
+        try {
+            const ok = await IpayCodePushNative.updateBundle({
+                bundleId: updateBundleId,
+                fileUrl: targetFileUrl,
+                fileHash: targetFileHash ?? null,
+            });
+
+            if (ok) {
+                lastInstalledBundleId = updateBundleId;
+            }
+
+            return ok;
+
+        } finally {
+            inflightUpdates.delete(updateBundleId);
+        }
+    })();
+
+    inflightUpdates.set(updateBundleId, promise);
+    return promise;
+}
+
+/**
+ * Fetches the current app version.
+ */
+export const getAppVersion = (): string | null => {
+    const constants = IpayCodePushNative.getConstants();
+    return constants?.APP_VERSION ?? null;
+};
+
+/**
+ * Reloads the app.
+ */
+export const reload = async () => {
+    await IpayCodePushNative.reload();
+};
+
+/**
+ * Fetches the minimum bundle id, which represents the initial bundle of the app
+ * since it is created at build time.
+ *
+ * @returns {string} Resolves with the minimum bundle id or null if not available.
+ */
+export const getMinBundleId = (): string => {
+    const constants = IpayCodePushNative.getConstants();
+    return constants.MIN_BUNDLE_ID;
+};
+
+/**
+ * Fetches the current bundle version id.
+ *
+ * @async
+ * @returns {string} Resolves with the current version id or null if not available.
+ */
+export const getBundleId = (): string => {
+  return IpayCodePushConstants.IPAY_CODE_PUSH_BUNDLE_ID === NIL_UUID
+    ? getMinBundleId()
+    : IpayCodePushConstants.IPAY_CODE_PUSH_BUNDLE_ID;
+};
+
+/**
+ * Fetches the channel for the app.
+ *
+ * @returns {string} Resolves with the channel or null if not available.
+ */
+export const getChannel = (): string => {
+    const constants = IpayCodePushNative.getConstants();
+    return constants.CHANNEL;
+};
+
+/**
+ * Fetches the fingerprint for the app.
+ *
+ * @returns {string | null} Resolves with the fingerprint hash
+ */
+export const getFingerprintHash = (): string | null => {
+    const constants = IpayCodePushNative.getConstants();
+    return constants.FINGERPRINT_HASH;
+};
+
+/**
+ * Result returned by notifyAppReady()
+ * - `status: "PROMOTED"` - Staging bundle was promoted to stable (ACTIVE event)
+ * - `status: "RECOVERED"` - App recovered from crash, rollback occurred (ROLLBACK event)
+ * - `status: "STABLE"` - No changes, already stable
+ * - `crashedBundleId` - Present only when status is "RECOVERED"
+ */
+export type NotifyAppReadyResult = {
+    status: "PROMOTED" | "RECOVERED" | "STABLE";
+    crashedBundleId?: string;
+};
+
+/**
+ * Notifies the native side that the app has successfully started with the current bundle.
+ * If the bundle matches the staging bundle, it promotes to stable.
+ *
+ * This function is called automatically when the module loads.
+ *
+ * @returns {NotifyAppReadyResult} Bundle state information
+ * - `status: "PROMOTED"` - Staging bundle was promoted to stable (ACTIVE event)
+ * - `status: "RECOVERED"` - App recovered from crash, rollback occurred (ROLLBACK event)
+ * - `status: "STABLE"` - No changes, already stable
+ * - `crashedBundleId` - Present only when status is "RECOVERED"
+ *
+ * @example
+ * ```ts
+ * const result = IpayCodePush.notifyAppReady();
+ *
+ * switch (result.status) {
+ *   case "PROMOTED":
+ *     // Send ACTIVE analytics event
+ *     analytics.track('bundle_active', { bundleId: IpayCodePush.getBundleId() });
+ *     break;
+ *   case "RECOVERED":
+ *     // Send ROLLBACK analytics event
+ *     analytics.track('bundle_rollback', { crashedBundleId: result.crashedBundleId });
+ *     break;
+ *   case "STABLE":
+ *     // No special action needed
+ *     break;
+ * }
+ * ```
+ */
+export const notifyAppReady = (): NotifyAppReadyResult => {
+    const bundleId = getBundleId();
+    const result = IpayCodePushNative.notifyAppReady({ bundleId });
+    // Oldarch returns JSON string, newarch returns array
+    if (typeof result === "string") {
+        try {
+            return JSON.parse(result);
+        } catch {
+            return { status: "STABLE" };
+        }
+    }
+    return result;
+};
+
+/**
+ * Gets the list of bundle IDs that have been marked as crashed.
+ * These bundles will be rejected if attempted to install again.
+ *
+ * @returns {string[]} Array of crashed bundle IDs
+ */
+export const getCrashHistory = (): string[] => {
+    const result = IpayCodePushNative.getCrashHistory();
+    // Oldarch returns JSON string, newarch returns array
+    if (typeof result === "string") {
+        try {
+            return JSON.parse(result);
+        } catch {
+            return [];
+        }
+    }
+    return result;
+};
+
+/**
+ * Clears the crashed bundle history, allowing previously crashed bundles
+ * to be installed again.
+ *
+ * @returns {boolean} true if clearing was successful
+ */
+export const clearCrashHistory = (): boolean => {
+    return IpayCodePushNative.clearCrashHistory();
+};
+
+/**
+ * Gets the base URL for the current active bundle directory.
+ * Returns the file:// URL to the bundle directory without trailing slash.
+ * This is used for Expo DOM components to construct full asset paths.
+ *
+ * @returns {string | null} Base URL string (e.g., "file:///data/.../bundle-store/abc123") or null if not available
+ */
+export const getBaseURL = (): string | null => {
+    const result = IpayCodePushNative.getBaseURL();
+    if (typeof result === "string" && result !== "") {
+        return result;
+    }
+    return null;
+};

package/src/store.ts

@@ -0,0 +1,69 @@
+import useSyncExternalStoreExports from "use-sync-external-store/shim/with-selector";
+
+export type IpayCodePushState = {
+    progress: number;
+    isUpdateDownloaded: boolean;
+};
+
+const { useSyncExternalStoreWithSelector } = useSyncExternalStoreExports;
+
+const createIpayCodePushStore = () => {
+
+    let state: IpayCodePushState = {
+        progress: 0,
+        isUpdateDownloaded: false,
+    };
+
+    const getSnapshot = () => {
+        return state;
+    };
+
+    const listeners = new Set<() => void>();
+
+    const emitChange = () => {
+        for (const listener of listeners) {
+            listener();
+        }
+    };
+
+    const setState = (newState: Partial<IpayCodePushState>) => {
+        // Merge first, then normalize derived fields
+        const nextState: IpayCodePushState = {
+            ...state,
+            ...newState,
+        };
+
+        // Derive `isUpdateDownloaded` from `progress` if provided.
+        // If `progress` is not provided but `isUpdateDownloaded` is,
+        // honor the explicit value.
+        if ("progress" in newState && typeof newState.progress === "number") {
+            nextState.isUpdateDownloaded = newState.progress >= 1;
+        } else if ("isUpdateDownloaded" in newState && typeof newState.isUpdateDownloaded === "boolean") {
+            nextState.isUpdateDownloaded = newState.isUpdateDownloaded;
+        }
+
+        state = nextState;
+        emitChange();
+    };
+
+    const subscribe = (listener: () => void) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+    };
+
+    return { getSnapshot, setState, subscribe };
+};
+
+export const ipayCodePushStore = createIpayCodePushStore();
+
+export const useIpayCodePushStore = <T = IpayCodePushState>(
+    selector: (snapshot: IpayCodePushState) => T = (snapshot) => snapshot as T,
+) => {
+    return useSyncExternalStoreWithSelector(
+        ipayCodePushStore.subscribe,
+        ipayCodePushStore.getSnapshot,
+        ipayCodePushStore.getSnapshot,
+        selector,
+    );
+};
+

package/src/types.ts

@@ -0,0 +1,227 @@
+
+/**
+ * Parameters passed to resolver.checkUpdate method
+ */
+export interface ResolverCheckUpdateParams {
+    /**
+     * The platform the app is running on
+     */
+    platform: "ios" | "android";
+
+    /**
+     * The current app version
+     */
+    appVersion: string;
+
+    /**
+     * The current bundle ID
+     */
+    bundleId: string;
+
+    /**
+     * Minimum bundle ID from build time
+     */
+    minBundleId: string;
+
+    /**
+     * The channel name (e.g., "production", "staging")
+     */
+    channel: string;
+
+    /**
+     * Update strategy being used
+     */
+    updateStrategy: "fingerprint" | "appVersion";
+
+    /**
+     * The fingerprint hash (only present when using fingerprint strategy)
+     */
+    fingerprintHash: string | null;
+
+    /**
+     * Request headers from global config (for optional use)
+     */
+    requestHeaders?: Record<string, string>;
+
+    /**
+     * Request timeout from global config (for optional use)
+     */
+    requestTimeout?: number;
+}
+
+/**
+ * Parameters passed to resolver.notifyAppReady method
+ */
+export interface ResolverNotifyAppReadyParams {
+    /**
+     * The bundle state from native notifyAppReady
+     * - "PROMOTED": Staging bundle was promoted to stable
+     * - "RECOVERED": App recovered from crash, rollback occurred
+     * - "STABLE": No changes, bundle is stable
+     */
+    status: "PROMOTED" | "RECOVERED" | "STABLE";
+
+    /**
+     * Present only when status is "RECOVERED"
+     */
+    crashedBundleId?: string;
+
+    /**
+     * Request headers from global config (for optional use)
+     */
+    requestHeaders?: Record<string, string>;
+
+    /**
+     * Request timeout from global config (for optional use)
+     */
+    requestTimeout?: number;
+}
+
+/**
+ * Resolver interface for custom network operations
+ */
+export interface IpayCodePushResolver {
+    /**
+     * Custom implementation for checking updates.
+     * When provided, this completely replaces the default fetchUpdateInfo flow.
+     *
+     * @param params - All parameters needed to check for updates
+     * @returns Update information or null if up to date
+     *
+     * @example
+     * ```typescript
+     * checkUpdate: async (params) => {
+     *   const response = await fetch(`https://api.custom.com/check`, {
+     *     method: 'POST',
+     *     body: JSON.stringify(params),
+     *     headers: params.requestHeaders,
+     *   });
+     *
+     *   if (!response.ok) return null;
+     *   return response.json();
+     * }
+     * ```
+     */
+    checkUpdate?: (
+        params: ResolverCheckUpdateParams,
+    ) => Promise<AppUpdateInfo | null>;
+
+    /**
+     * Custom implementation for notifying app ready.
+     * When provided, this completely replaces the default notifyAppReady network flow.
+     * Note: The native notifyAppReady for bundle promotion still happens automatically.
+     *
+     * @param params - All parameters about the current app state
+     * @returns Notification result
+     *
+     * @example
+     * ```typescript
+     * notifyAppReady: async (params) => {
+     *   await fetch(`https://api.custom.com/notify`, {
+     *     method: 'POST',
+     *     body: JSON.stringify(params),
+     *   });
+     *
+     *   return { status: "STABLE" };
+     * }
+     * ```
+     */
+    notifyAppReady?: (
+        params: ResolverNotifyAppReadyParams,
+    ) => Promise<undefined>; //Promise<NotifyAppReadyResult | undefined>;
+}
+
+/**
+ * Information about a signature verification failure.
+ * This is a security-critical event that indicates the bundle
+ * may have been tampered with or the public key is misconfigured.
+ */
+export interface SignatureVerificationFailure {
+    /**
+     * The bundle ID that failed verification.
+     */
+    bundleId: string;
+    /**
+     * Human-readable error message from the native layer.
+     */
+    message: string;
+    /**
+     * The underlying error object.
+     */
+    error: Error;
+}
+
+/**
+ * Checks if an error is a signature verification failure.
+ * Matches error messages from both iOS and Android native implementations.
+ *
+ * **IMPORTANT**: This function relies on specific error message patterns from native code.
+ * If you change the error messages in the native implementations, update these patterns:
+ * - iOS: `ios/ipaycodepush/Internal/SignatureVerifier.swift` (SignatureVerificationError)
+ * - Android: `android/src/main/java/com/ipaycodepush/SignatureVerifier.kt` (SignatureVerificationException)
+ */
+export function isSignatureVerificationError(error: unknown): boolean {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+
+    const message = error.message.toLowerCase();
+
+    // Match iOS SignatureVerificationError messages
+    // Match Android SignatureVerificationException messages
+    return (
+        message.includes("signature verification") ||
+        message.includes("public key not configured") ||
+        message.includes("public key format is invalid") ||
+        message.includes("signature format is invalid") ||
+        message.includes("bundle may be corrupted or tampered")
+    );
+}
+
+/**
+ * Extracts signature verification failure details from an error.
+ */
+export function extractSignatureFailure(
+    error: unknown,
+    bundleId: string,
+): SignatureVerificationFailure {
+    const normalizedError =
+        error instanceof Error ? error : new Error(String(error));
+
+    return {
+        bundleId,
+        message: normalizedError.message,
+        error: normalizedError,
+    };
+}
+
+
+export type UpdateStatus = "ROLLBACK" | "UPDATE";
+
+/**
+ * The update info for the database layer.
+ * This is the update info that is used by the database.
+ */
+export interface UpdateInfo {
+    id: string;
+    shouldForceUpdate: boolean;
+    message: string | null;
+    status: UpdateStatus;
+    storageUri: string | null;
+    fileHash: string | null;
+}
+
+/**
+ * The update info for the app layer.
+ * This is the update info that is used by the app.
+ */
+export interface AppUpdateInfo extends Omit<UpdateInfo, "storageUri"> {
+    fileUrl: string | null;
+    /**
+     * SHA256 hash of the bundle file, optionally with embedded signature.
+     * Format when signed: "sig:<base64_signature>"
+     * Format when unsigned: "<hex_hash>" (64-character lowercase hex)
+     * The client parses this to extract signature for native verification.
+     */
+    fileHash: string | null;
+}