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

package/ios/HotUpdater/Internal/UpdateFailure.swift

@@ -0,0 +1,390 @@
+import Foundation
+
+/// Where an update failed: `download` covers transferring the update's files
+/// and verifying the downloaded bytes, and `install` covers producing the
+/// bundle on disk (patching, extracting, and moving files into place).
+enum UpdateFailureStage: String {
+    case download
+    case install
+}
+
+/// Why an update failed.
+enum UpdateFailureReason: String {
+    case network
+    case http
+    case invalidResponse = "invalid_response"
+    case hashMismatch = "hash_mismatch"
+    case signature
+    case patch
+    case extract
+    case storage
+    case unknown
+}
+
+/// What was being fetched or applied when an update failed.
+enum UpdateFailureResource: String {
+    case manifest
+    case file
+    case patch
+    case archive
+}
+
+/// How a transfer failed when no HTTP response arrived.
+enum UpdateFailureTransport: String {
+    case timeout
+    case dns
+    case tls
+    case connection
+    case offline
+    case cancelled
+
+    /// Returns nil for codes that do not name a transport failure.
+    init?(_ code: URLError.Code) {
+        switch code {
+        case .timedOut:
+            self = .timeout
+        case .cannotFindHost, .dnsLookupFailed:
+            self = .dns
+        case .secureConnectionFailed,
+             .serverCertificateHasBadDate,
+             .serverCertificateUntrusted,
+             .serverCertificateHasUnknownRoot,
+             .serverCertificateNotYetValid,
+             .clientCertificateRejected,
+             .clientCertificateRequired:
+            self = .tls
+        case .cannotConnectToHost, .networkConnectionLost:
+            self = .connection
+        case .notConnectedToInternet, .dataNotAllowed, .internationalRoamingOff:
+            self = .offline
+        case .cancelled:
+            self = .cancelled
+        default:
+            return nil
+        }
+    }
+}
+
+/// The classification an `updateBundle` rejection carries in its userInfo.
+struct UpdateFailure: Equatable {
+    static let stageKey = "stage"
+    static let reasonKey = "reason"
+    static let resourceKey = "resource"
+    static let httpStatusKey = "httpStatus"
+    static let transportKey = "transport"
+    static let originCodeKey = "originCode"
+
+    static let network = UpdateFailure(stage: .download, reason: .network)
+    static let invalidResponse = UpdateFailure(stage: .download, reason: .invalidResponse)
+    static let hashMismatch = UpdateFailure(stage: .download, reason: .hashMismatch)
+    static let signature = UpdateFailure(stage: .download, reason: .signature)
+    static let patch = UpdateFailure(stage: .install, reason: .patch)
+    static let extract = UpdateFailure(stage: .install, reason: .extract)
+    static let storage = UpdateFailure(stage: .install, reason: .storage)
+
+    static func network(transport: UpdateFailureTransport?) -> UpdateFailure {
+        UpdateFailure(stage: .download, reason: .network, transport: transport)
+    }
+
+    static func http(status: Int, originCode: String? = nil) -> UpdateFailure {
+        UpdateFailure(
+            stage: .download,
+            reason: .http,
+            httpStatus: status,
+            originCode: originCode
+        )
+    }
+
+    static func unknown(_ stage: UpdateFailureStage) -> UpdateFailure {
+        UpdateFailure(stage: stage, reason: .unknown)
+    }
+
+    let stage: UpdateFailureStage
+    let reason: UpdateFailureReason
+    /// What was being fetched or applied, when the failure concerns one.
+    private(set) var resource: UpdateFailureResource?
+    /// The response status; only set when `reason` is `.http`.
+    let httpStatus: Int?
+    /// Only set when `reason` is `.network` and no response arrived.
+    let transport: UpdateFailureTransport?
+    /// The storage origin's XML error code; only set when `reason` is `.http`.
+    let originCode: String?
+
+    private init(
+        stage: UpdateFailureStage,
+        reason: UpdateFailureReason,
+        httpStatus: Int? = nil,
+        transport: UpdateFailureTransport? = nil,
+        originCode: String? = nil
+    ) {
+        self.stage = stage
+        self.reason = reason
+        self.httpStatus = httpStatus
+        self.transport = transport
+        self.originCode = originCode
+    }
+
+    /// This failure, attributed to `resource` unless it already names one.
+    func with(resource: UpdateFailureResource?) -> UpdateFailure {
+        guard self.resource == nil, let resource else {
+            return self
+        }
+        var failure = self
+        failure.resource = resource
+        return failure
+    }
+
+    /// JSON-safe entries React Native copies into the JS error's `userInfo`.
+    var userInfo: [String: Any] {
+        var userInfo: [String: Any] = [
+            Self.stageKey: stage.rawValue,
+            Self.reasonKey: reason.rawValue,
+        ]
+        if let resource {
+            userInfo[Self.resourceKey] = resource.rawValue
+        }
+        if let httpStatus {
+            userInfo[Self.httpStatusKey] = NSNumber(value: httpStatus)
+        }
+        if let transport {
+            userInfo[Self.transportKey] = transport.rawValue
+        }
+        if let originCode {
+            userInfo[Self.originCodeKey] = originCode
+        }
+        return userInfo
+    }
+
+    /// An error carrying this classification, for rejections raised before
+    /// the update pipeline starts, such as invalid `updateBundle` parameters.
+    func error(description: String) -> NSError {
+        var userInfo = self.userInfo
+        userInfo[NSLocalizedDescriptionKey] = description
+        return NSError(domain: "HotUpdater", code: 0, userInfo: userInfo)
+    }
+}
+
+/// The update step an error came from. It classifies the errors whose type
+/// does not: a hash mismatch is a download failure after a transfer but a
+/// patch failure after patching, and an unexpected error keeps the stage.
+enum UpdatePhase {
+    /// Transferring manifest, archive, asset, or patch bytes.
+    case transfer
+    /// Checking downloaded bytes against the manifest.
+    case verification
+    /// Parsing and validating the manifest against the update parameters.
+    case manifest
+    /// Applying a bsdiff patch and checking its output.
+    case patch
+    /// Decoding brotli or tar data and checking the extracted files.
+    case extraction
+    /// Creating directories and copying, moving, or writing files.
+    case storage
+}
+
+/// An update pipeline error and its classification. `underlying` still
+/// decides the rejection code, so classifying an error never changes it.
+struct UpdateFailureError: Error {
+    let underlying: Error
+    let failure: UpdateFailure
+
+    /// Classifies `error` as raised during `phase` while fetching or applying
+    /// `resource`. An error that is already classified keeps its
+    /// classification and only gains a missing resource. Returns `error`
+    /// unchanged when it is not an update failure.
+    static func classifying(
+        _ error: Error,
+        during phase: UpdatePhase,
+        resource: UpdateFailureResource? = nil
+    ) -> Error {
+        if let classified = error as? UpdateFailureError {
+            return UpdateFailureError(
+                underlying: classified.underlying,
+                failure: classified.failure.with(resource: resource)
+            )
+        }
+        guard let failure = UpdateFailureClassifier.classify(error, during: phase) else {
+            return error
+        }
+        return UpdateFailureError(underlying: error, failure: failure.with(resource: resource))
+    }
+
+    /// Runs `body`, classifying what it throws as raised during `phase`.
+    static func during<T>(
+        _ phase: UpdatePhase,
+        resource: UpdateFailureResource? = nil,
+        _ body: () throws -> T
+    ) throws -> T {
+        do {
+            return try body()
+        } catch {
+            throw classifying(error, during: phase, resource: resource)
+        }
+    }
+
+    /// The error that decides the rejection code.
+    static func unwrap(_ error: Error) -> Error {
+        (error as? UpdateFailureError)?.underlying ?? error
+    }
+
+    /// The error `updateBundle` rejects with: the underlying error's domain,
+    /// code, and userInfo, plus the classification entries.
+    static func rejectionError(for error: Error) -> NSError {
+        guard let classified = error as? UpdateFailureError else {
+            return error as NSError
+        }
+        let underlying = classified.underlying as NSError
+        var userInfo = underlying.userInfo
+        userInfo[NSLocalizedDescriptionKey] = underlying.localizedDescription
+        userInfo.merge(classified.failure.userInfo) { _, classification in classification }
+        return NSError(domain: underlying.domain, code: underlying.code, userInfo: userInfo)
+    }
+}
+
+extension UpdateFailureError: LocalizedError {
+    var errorDescription: String? {
+        underlying.localizedDescription
+    }
+}
+
+/// The Release selection an install was staged for changed before the bundle
+/// was activated. The rejection is not an update failure.
+struct StaleReleaseSelectionError: Error, CustomNSError {
+    static var errorDomain: String {
+        "HotUpdater"
+    }
+
+    var errorCode: Int {
+        0
+    }
+
+    var errorUserInfo: [String: Any] {
+        [NSLocalizedDescriptionKey: "Release catalog selection is stale"]
+    }
+}
+
+enum UpdateFailureClassifier {
+    /// Classifies an error raised during `phase`, or returns nil when the
+    /// error is not an update failure.
+    static func classify(_ error: Error, during phase: UpdatePhase) -> UpdateFailure? {
+        switch error {
+        case let error as UpdateFailureError:
+            return error.failure
+        case is StaleReleaseSelectionError:
+            return nil
+        case let error as BundleStorageError:
+            return classifyStorageError(error, during: phase)
+        case let error as SignatureVerificationError:
+            return classifySignatureError(error, during: phase)
+        case let error as DownloadError:
+            return classifyDownloadError(error)
+        case let error as URLError:
+            return classifyURLError(error)
+        default:
+            return isFileSystemError(error) ? .storage : fallback(during: phase)
+        }
+    }
+
+    private static func classifyStorageError(
+        _ error: BundleStorageError,
+        during phase: UpdatePhase
+    ) -> UpdateFailure? {
+        switch error {
+        case .directoryCreationFailed, .moveOperationFailed:
+            return .storage
+        case .downloadFailed(let underlying):
+            return classify(underlying, during: .transfer)
+        case .incompleteDownload:
+            return .network
+        case .invalidBundle:
+            return .invalidResponse
+        case .signatureVerificationFailed(let underlying):
+            return classifySignatureError(underlying, during: phase)
+        case .bundleInCrashedHistory:
+            return nil
+        case .unknown(.some(let underlying)):
+            return classify(underlying, during: phase)
+        case .unknown(.none):
+            return fallback(during: phase)
+        }
+    }
+
+    private static func classifySignatureError(
+        _ error: SignatureVerificationError,
+        during phase: UpdatePhase
+    ) -> UpdateFailure {
+        switch error {
+        case .fileHashMismatch:
+            switch phase {
+            case .patch:
+                return .patch
+            case .extraction:
+                return .extract
+            case .transfer, .verification, .manifest, .storage:
+                return .hashMismatch
+            }
+        case .fileReadFailed:
+            return .storage
+        case .missingFileHash:
+            return .invalidResponse
+        case .publicKeyNotConfigured,
+             .invalidPublicKeyFormat,
+             .invalidSignatureFormat,
+             .signatureVerificationFailed,
+             .unsignedNotAllowed,
+             .securityFrameworkError:
+            return .signature
+        }
+    }
+
+    private static func classifyDownloadError(_ error: DownloadError) -> UpdateFailure {
+        switch error {
+        case .httpStatus(let status, let originCode):
+            return .http(status: status, originCode: originCode)
+        case .incompleteDownload, .invalidContentLength:
+            // A response arrived, so the failure names no transport.
+            return .network
+        }
+    }
+
+    private static func classifyURLError(_ error: URLError) -> UpdateFailure {
+        switch error.code {
+        case .badURL, .unsupportedURL:
+            return .invalidResponse
+        case .cannotCreateFile,
+             .cannotOpenFile,
+             .cannotCloseFile,
+             .cannotWriteToFile,
+             .cannotRemoveFile,
+             .cannotMoveFile:
+            return .storage
+        default:
+            return .network(transport: UpdateFailureTransport(error.code))
+        }
+    }
+
+    private static func isFileSystemError(_ error: Error) -> Bool {
+        if error is FileSystemError {
+            return true
+        }
+        if let cocoaError = error as? CocoaError {
+            return cocoaError.isFileError
+        }
+        return (error as NSError).domain == NSPOSIXErrorDomain
+    }
+
+    private static func fallback(during phase: UpdatePhase) -> UpdateFailure {
+        switch phase {
+        case .transfer, .verification:
+            return .unknown(.download)
+        case .manifest:
+            return .invalidResponse
+        case .patch:
+            return .patch
+        case .extraction:
+            return .extract
+        case .storage:
+            return .unknown(.install)
+        }
+    }
+}

package/lib/commonjs/appReady.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleNotifyAppReady = exports.getRunningReleaseId = exports.getPreviousProcessExit = exports.emitAfterAppReady = void 0;
+var _native = require("./native.js");
+var _pluginHost = require("./pluginHost.js");
+let didEmitAppReady = false;
+/** Settles once this runtime's launch was read, whether it was reported or failed. */
+let appReadyRead = null;
+/** Why the previous main process exited, read with this runtime's launch. */
+let previousProcessExit = null;
+
+/** Android 11+: why the app's previous main process exited, once the launch was read. */
+const getPreviousProcessExit = () => previousProcessExit;
+exports.getPreviousProcessExit = getPreviousProcessExit;
+const waitForNextFrame = () => new Promise(resolve => {
+  const requestAnimationFrame = globalThis?.requestAnimationFrame;
+  if (requestAnimationFrame) {
+    requestAnimationFrame(() => resolve());
+    return;
+  }
+  void Promise.resolve().then(resolve);
+});
+
+/**
+ * The Release the running bundle was selected as: the active or stable
+ * selection that names it on the current channel.
+ */
+const getRunningReleaseId = (bundleId, channel) => {
+  const state = (0, _native.getActiveUpdateState)();
+  return [state.activeSelection, state.stableSelection].find(selection => selection?.bundleId === bundleId && selection.channel === channel)?.releaseId ?? null;
+};
+exports.getRunningReleaseId = getRunningReleaseId;
+const toAppReadyResult = (result, transition) => {
+  const channel = (0, _native.getChannel)();
+  if (result.status === "UNCHANGED") {
+    const bundleId = (0, _native.getBundleId)();
+    return {
+      status: "UNCHANGED",
+      channel,
+      bundleId,
+      releaseId: getRunningReleaseId(bundleId, channel),
+      previousProcessExit
+    };
+  }
+  // Native persists the transition with every applied or recovered launch;
+  // a report without it cannot say what moved.
+  if (transition === null) return null;
+  return {
+    status: transition.type,
+    channel,
+    fromBundleId: transition.fromBundleId,
+    fromReleaseId: transition.fromReleaseId,
+    toBundleId: transition.toBundleId,
+    toReleaseId: transition.toReleaseId,
+    updateStrategy: transition.updateStrategy,
+    previousProcessExit
+  };
+};
+const notifyAppReady = async options => {
+  try {
+    let nativeReadResult;
+    do {
+      await waitForNextFrame();
+      nativeReadResult = (0, _native.readNotifyAppReady)();
+    } while (nativeReadResult.pending);
+    const {
+      result,
+      transition
+    } = nativeReadResult;
+    previousProcessExit = nativeReadResult.previousProcessExit;
+    if (!didEmitAppReady) {
+      didEmitAppReady = true;
+      (0, _pluginHost.emitPluginHook)("onAppReady", () => toAppReadyResult(result, transition));
+    }
+    options.onNotifyAppReady?.(result);
+    return result;
+  } catch (error) {
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    options.onError?.(error);
+    console.warn("[HotUpdater] Failed to notify app ready:", normalizedError);
+    return undefined;
+  }
+};
+
+/** Reads this runtime's launch once native finalizes it and reports it to plugins. */
+const handleNotifyAppReady = options => {
+  const readiness = notifyAppReady(options);
+  appReadyRead ??= readiness;
+  return readiness;
+};
+
+/**
+ * Calls a plugin hook after this runtime's `onAppReady`, so plugins see the
+ * launch before anything that followed it. The event is built now, from the
+ * state it describes, and only when a plugin listens.
+ */
+exports.handleNotifyAppReady = handleNotifyAppReady;
+const emitAfterAppReady = (name, createPayload) => {
+  const payload = (0, _pluginHost.buildPluginEvent)(name, createPayload);
+  if (payload === null) return;
+  if (appReadyRead === null) {
+    (0, _pluginHost.dispatchPluginHook)(name, payload);
+    return;
+  }
+  void appReadyRead.then(() => (0, _pluginHost.dispatchPluginHook)(name, payload));
+};
+exports.emitAfterAppReady = emitAfterAppReady;
+//# sourceMappingURL=appReady.js.map

package/lib/commonjs/appReady.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_native","require","_pluginHost","didEmitAppReady","appReadyRead","previousProcessExit","getPreviousProcessExit","exports","waitForNextFrame","Promise","resolve","requestAnimationFrame","globalThis","then","getRunningReleaseId","bundleId","channel","state","getActiveUpdateState","activeSelection","stableSelection","find","selection","releaseId","toAppReadyResult","result","transition","getChannel","status","getBundleId","type","fromBundleId","fromReleaseId","toBundleId","toReleaseId","updateStrategy","notifyAppReady","options","nativeReadResult","readNotifyAppReady","pending","emitPluginHook","onNotifyAppReady","error","normalizedError","Error","String","onError","console","warn","undefined","handleNotifyAppReady","readiness","emitAfterAppReady","name","createPayload","payload","buildPluginEvent","dispatchPluginHook"],"sourceRoot":"../../src","sources":["appReady.ts"],"mappings":";;;;;;AAEA,IAAAA,OAAA,GAAAC,OAAA;AAQA,IAAAC,WAAA,GAAAD,OAAA;AAaA,IAAIE,eAAe,GAAG,KAAK;AAC3B;AACA,IAAIC,YAAqC,GAAG,IAAI;AAChD;AACA,IAAIC,mBAAkC,GAAG,IAAI;;AAE7C;AACO,MAAMC,sBAAsB,GAAGA,CAAA,KAAqBD,mBAAmB;AAACE,OAAA,CAAAD,sBAAA,GAAAA,sBAAA;AAE/E,MAAME,gBAAgB,GAAGA,CAAA,KACvB,IAAIC,OAAO,CAAQC,OAAO,IAAK;EAC7B,MAAMC,qBAAqB,GACzBC,UAAU,EAGTD,qBAAqB;EAExB,IAAIA,qBAAqB,EAAE;IACzBA,qBAAqB,CAAC,MAAMD,OAAO,CAAC,CAAC,CAAC;IACtC;EACF;EAEA,KAAKD,OAAO,CAACC,OAAO,CAAC,CAAC,CAACG,IAAI,CAACH,OAAO,CAAC;AACtC,CAAC,CAAC;;AAEJ;AACA;AACA;AACA;AACO,MAAMI,mBAAmB,GAAGA,CACjCC,QAAgB,EAChBC,OAAe,KACG;EAClB,MAAMC,KAAK,GAAG,IAAAC,4BAAoB,EAAC,CAAC;EACpC,OACE,CAACD,KAAK,CAACE,eAAe,EAAEF,KAAK,CAACG,eAAe,CAAC,CAACC,IAAI,CAChDC,SAAS,IACRA,SAAS,EAAEP,QAAQ,KAAKA,QAAQ,IAAIO,SAAS,CAACN,OAAO,KAAKA,OAC9D,CAAC,EAAEO,SAAS,IAAI,IAAI;AAExB,CAAC;AAAChB,OAAA,CAAAO,mBAAA,GAAAA,mBAAA;AAEF,MAAMU,gBAAgB,GAAGA,CACvBC,MAA4B,EAC5BC,UAAmC,KACT;EAC1B,MAAMV,OAAO,GAAG,IAAAW,kBAAU,EAAC,CAAC;EAC5B,IAAIF,MAAM,CAACG,MAAM,KAAK,WAAW,EAAE;IACjC,MAAMb,QAAQ,GAAG,IAAAc,mBAAW,EAAC,CAAC;IAC9B,OAAO;MACLD,MAAM,EAAE,WAAW;MACnBZ,OAAO;MACPD,QAAQ;MACRQ,SAAS,EAAET,mBAAmB,CAACC,QAAQ,EAAEC,OAAO,CAAC;MACjDX;IACF,CAAC;EACH;EACA;EACA;EACA,IAAIqB,UAAU,KAAK,IAAI,EAAE,OAAO,IAAI;EACpC,OAAO;IACLE,MAAM,EAAEF,UAAU,CAACI,IAAI;IACvBd,OAAO;IACPe,YAAY,EAAEL,UAAU,CAACK,YAAY;IACrCC,aAAa,EAAEN,UAAU,CAACM,aAAa;IACvCC,UAAU,EAAEP,UAAU,CAACO,UAAU;IACjCC,WAAW,EAAER,UAAU,CAACQ,WAAW;IACnCC,cAAc,EAAET,UAAU,CAACS,cAAc;IACzC9B;EACF,CAAC;AACH,CAAC;AAED,MAAM+B,cAAc,GAAG,MACrBC,OAA8B,IACgB;EAC9C,IAAI;IACF,IAAIC,gBAAuD;IAC3D,GAAG;MACD,MAAM9B,gBAAgB,CAAC,CAAC;MACxB8B,gBAAgB,GAAG,IAAAC,0BAAkB,EAAC,CAAC;IACzC,CAAC,QAAQD,gBAAgB,CAACE,OAAO;IAEjC,MAAM;MAAEf,MAAM;MAAEC;IAAW,CAAC,GAAGY,gBAAgB;IAC/CjC,mBAAmB,GAAGiC,gBAAgB,CAACjC,mBAAmB;IAC1D,IAAI,CAACF,eAAe,EAAE;MACpBA,eAAe,GAAG,IAAI;MACtB,IAAAsC,0BAAc,EAAC,YAAY,EAAE,MAAMjB,gBAAgB,CAACC,MAAM,EAAEC,UAAU,CAAC,CAAC;IAC1E;IAEAW,OAAO,CAACK,gBAAgB,GAAGjB,MAAM,CAAC;IAClC,OAAOA,MAAM;EACf,CAAC,CAAC,OAAOkB,KAAK,EAAE;IACd,MAAMC,eAAe,GACnBD,KAAK,YAAYE,KAAK,GAAGF,KAAK,GAAG,IAAIE,KAAK,CAACC,MAAM,CAACH,KAAK,CAAC,CAAC;IAC3DN,OAAO,CAACU,OAAO,GAAGJ,KAAK,CAAC;IACxBK,OAAO,CAACC,IAAI,CAAC,0CAA0C,EAAEL,eAAe,CAAC;IACzE,OAAOM,SAAS;EAClB;AACF,CAAC;;AAED;AACO,MAAMC,oBAAoB,GAC/Bd,OAA8B,IACgB;EAC9C,MAAMe,SAAS,GAAGhB,cAAc,CAACC,OAAO,CAAC;EACzCjC,YAAY,KAAKgD,SAAS;EAC1B,OAAOA,SAAS;AAClB,CAAC;;AAED;AACA;AACA;AACA;AACA;AAJA7C,OAAA,CAAA4C,oBAAA,GAAAA,oBAAA;AAKO,MAAME,iBAAwC,GAAGA,CACtDC,IAAI,EACJC,aAAa,KACV;EACH,MAAMC,OAAO,GAAG,IAAAC,4BAAgB,EAACH,IAAI,EAAEC,aAAa,CAAC;EACrD,IAAIC,OAAO,KAAK,IAAI,EAAE;EACtB,IAAIpD,YAAY,KAAK,IAAI,EAAE;IACzB,IAAAsD,8BAAkB,EAACJ,IAAI,EAAEE,OAAO,CAAC;IACjC;EACF;EACA,KAAKpD,YAAY,CAACS,IAAI,CAAC,MAAM,IAAA6C,8BAAkB,EAACJ,IAAI,EAAEE,OAAO,CAAC,CAAC;AACjE,CAAC;AAACjD,OAAA,CAAA8C,iBAAA,GAAAA,iBAAA","ignoreList":[]}