pulse-updates 1.0.0

package/ios/PulseUpdates/PulseTypes.swift

@@ -0,0 +1,289 @@
+// PulseUpdates Shared Types
+// Common models and types used across the module
+
+import Foundation
+
+// MARK: - Configuration
+
+public struct PulseUpdatesConfig {
+    public let enabled: Bool
+    public let updateUrl: String
+    public let runtimeVersion: String
+    public let checkOnLaunch: String
+    public let launchWaitMs: Int
+    public let channel: String?
+    public let signingKeyId: String?
+    public let signingPublicKey: String?
+    public let scopeKey: String
+
+    public init(
+        enabled: Bool,
+        updateUrl: String,
+        runtimeVersion: String,
+        checkOnLaunch: String = "ALWAYS",
+        launchWaitMs: Int = 0,
+        channel: String? = nil,
+        signingKeyId: String? = nil,
+        signingPublicKey: String? = nil
+    ) {
+        self.enabled = enabled
+        self.updateUrl = updateUrl
+        self.runtimeVersion = runtimeVersion
+        self.checkOnLaunch = checkOnLaunch
+        self.launchWaitMs = launchWaitMs
+        self.channel = channel
+        self.signingKeyId = signingKeyId
+        self.signingPublicKey = signingPublicKey
+        // Use update URL host as scope key (like Expo)
+        self.scopeKey = URL(string: updateUrl)?.host ?? "default"
+    }
+}
+
+// MARK: - Manifest Models
+
+public struct PulseManifestModel: Codable {
+    public let updateId: String
+    public let runtimeVersion: String
+    public let createdAt: String
+    public let bundle: PulseBundleModel
+    public let assets: [PulseAssetModel]
+    public let metadata: [String: String]?
+    public let signature: PulseSignatureModel?
+
+    public var commitTime: Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return formatter.date(from: createdAt) ?? ISO8601DateFormatter().date(from: createdAt)
+    }
+}
+
+public struct PulseBundleModel: Codable {
+    public let hash: String
+    public let url: String
+    public let contentType: String
+}
+
+public struct PulseAssetModel: Codable {
+    public let key: String?
+    public let hash: String
+    public let url: String
+    public let contentType: String
+    // Expo-compatible fields for embedded asset lookup
+    public let name: String?
+    public let type: String?
+    public let scale: Double?
+    public let nsBundleDir: String?
+    public let nsBundleFilename: String?
+
+    public init(
+        key: String?,
+        hash: String,
+        url: String,
+        contentType: String,
+        name: String? = nil,
+        type: String? = nil,
+        scale: Double? = nil,
+        nsBundleDir: String? = nil,
+        nsBundleFilename: String? = nil
+    ) {
+        self.key = key
+        self.hash = hash
+        self.url = url
+        self.contentType = contentType
+        self.name = name
+        self.type = type
+        self.scale = scale
+        self.nsBundleDir = nsBundleDir
+        self.nsBundleFilename = nsBundleFilename
+    }
+}
+
+public struct PulseSignatureModel: Codable {
+    public let alg: String
+    public let keyId: String
+    public let sig: String
+}
+
+// MARK: - Update Status
+
+public enum PulseUpdateStatus: String, Codable {
+    case pending = "pending"
+    case downloading = "downloading"
+    case ready = "ready"
+    case embedded = "embedded"
+    case development = "development"
+    case failed = "failed"
+
+    // Legacy compatibility
+    static func fromLegacy(_ value: String) -> PulseUpdateStatus {
+        switch value.uppercased() {
+        case "DOWNLOADING": return .downloading
+        case "READY": return .ready
+        case "FAILED": return .failed
+        case "EMBEDDED": return .embedded
+        case "DEVELOPMENT": return .development
+        default: return .pending
+        }
+    }
+
+    // Database string conversion
+    init?(dbValue: String?) {
+        guard let value = dbValue else { return nil }
+        self.init(rawValue: value)
+    }
+}
+
+// MARK: - Update Info (for SelectionPolicy)
+
+public struct PulseUpdateInfo {
+    public let updateId: String
+    public let runtimeVersion: String
+    public let commitTime: Date
+    public let status: PulseUpdateStatus
+    public let successfulLaunchCount: Int
+    public let failedLaunchCount: Int
+    public let isEmbedded: Bool
+    public let bundleHash: String?
+    public let scopeKey: String?
+
+    public init(
+        updateId: String,
+        runtimeVersion: String,
+        commitTime: Date,
+        status: PulseUpdateStatus,
+        successfulLaunchCount: Int = 0,
+        failedLaunchCount: Int = 0,
+        isEmbedded: Bool = false,
+        bundleHash: String? = nil,
+        scopeKey: String? = nil
+    ) {
+        self.updateId = updateId
+        self.runtimeVersion = runtimeVersion
+        self.commitTime = commitTime
+        self.status = status
+        self.successfulLaunchCount = successfulLaunchCount
+        self.failedLaunchCount = failedLaunchCount
+        self.isEmbedded = isEmbedded
+        self.bundleHash = bundleHash
+        self.scopeKey = scopeKey
+    }
+}
+
+// MARK: - Remote Load Status
+
+public enum PulseRemoteLoadStatus: String {
+    case idle = "Idle"
+    case loading = "Loading"
+    case newUpdateLoaded = "NewUpdateLoaded"
+    case updateUnavailable = "UpdateUnavailable"
+}
+
+// MARK: - Check Result
+
+public struct PulseCheckResult {
+    public let isAvailable: Bool
+    public let manifest: PulseManifestModel?
+    public let isRollback: Bool
+    public let failedReason: String?
+
+    public init(isAvailable: Bool, manifest: PulseManifestModel? = nil, isRollback: Bool = false, failedReason: String? = nil) {
+        self.isAvailable = isAvailable
+        self.manifest = manifest
+        self.isRollback = isRollback
+        self.failedReason = failedReason
+    }
+}
+
+// MARK: - Fetch Result
+
+public struct PulseFetchResult {
+    public let isNew: Bool
+    public let manifest: PulseManifestModel?
+
+    public init(isNew: Bool, manifest: PulseManifestModel? = nil) {
+        self.isNew = isNew
+        self.manifest = manifest
+    }
+}
+
+// MARK: - Errors
+
+public enum PulseUpdatesError: Error, LocalizedError {
+    case notConfigured
+    case notEnabled
+    case networkError(underlying: Error)
+    case invalidManifest(reason: String)
+    case signatureVerificationFailed
+    case hashMismatch(expected: String, actual: String)
+    case downloadFailed(underlying: Error)
+    case noUpdateAvailable
+    case updateNotReady
+    case databaseError(underlying: Error)
+    case launchFailed(reason: String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .notConfigured:
+            return "PulseUpdates is not configured"
+        case .notEnabled:
+            return "PulseUpdates is not enabled"
+        case .networkError(let error):
+            return "Network error: \(error.localizedDescription)"
+        case .invalidManifest(let reason):
+            return "Invalid manifest: \(reason)"
+        case .signatureVerificationFailed:
+            return "Signature verification failed"
+        case .hashMismatch(let expected, let actual):
+            return "Hash mismatch: expected \(expected), got \(actual)"
+        case .downloadFailed(let error):
+            return "Download failed: \(error.localizedDescription)"
+        case .noUpdateAvailable:
+            return "No update available"
+        case .updateNotReady:
+            return "Update is not ready to launch"
+        case .databaseError(let error):
+            return "Database error: \(error.localizedDescription)"
+        case .launchFailed(let reason):
+            return "Launch failed: \(reason)"
+        }
+    }
+}
+
+// MARK: - Event Types
+
+public enum PulseUpdatesEventType: String {
+    case noUpdateAvailable = "noUpdateAvailable"
+    case updateAvailable = "updateAvailable"
+    case downloadStart = "downloadStart"
+    case downloadProgress = "downloadProgress"
+    case downloadComplete = "downloadComplete"
+    case error = "error"
+}
+
+// MARK: - Logging
+
+/// Debug logging - only prints in DEBUG builds or when PULSE_DEBUG env var is set
+public func pulseLog(_ message: String) {
+    #if DEBUG
+    print("[PulseUpdates] \(message)")
+    #else
+    if ProcessInfo.processInfo.environment["PULSE_DEBUG"] != nil {
+        print("[PulseUpdates] \(message)")
+    }
+    #endif
+}
+
+public func pulseLogWarn(_ message: String) {
+    #if DEBUG
+    print("[PulseUpdates] WARN: \(message)")
+    #else
+    if ProcessInfo.processInfo.environment["PULSE_DEBUG"] != nil {
+        print("[PulseUpdates] WARN: \(message)")
+    }
+    #endif
+}
+
+public func pulseLogError(_ message: String) {
+    // Always log errors
+    print("[PulseUpdates] ERROR: \(message)")
+}

package/ios/PulseUpdates/PulseUpdates.m

@@ -0,0 +1,37 @@
+// PulseUpdates Objective-C Bridge
+// Exposes Swift module to React Native
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(PulseUpdates, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(configure:(BOOL)enabled
+                  updateUrl:(NSString *)updateUrl
+                  runtimeVersion:(NSString *)runtimeVersion
+                  checkOnLaunch:(NSString *)checkOnLaunch
+                  launchWaitMs:(int)launchWaitMs
+                  channel:(NSString *)channel
+                  signingKeyId:(NSString *)signingKeyId
+                  signingPublicKey:(NSString *)signingPublicKey)
+
+RCT_EXTERN_METHOD(getStateAsync:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(checkForUpdateAsync:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(fetchUpdateAsync:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reloadAsync:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(markAppReady:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportLaunchFailure:(NSString *)reason
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/PulseUpdates/PulseUpdates.swift

@@ -0,0 +1,236 @@
+// PulseUpdates React Native Module
+// Bridges PulseController to React Native
+
+import Foundation
+import React
+
+@objc(PulseUpdates)
+public class PulseUpdates: RCTEventEmitter {
+
+    // MARK: - RCTEventEmitter
+
+    public override func supportedEvents() -> [String]! {
+        return ["PulseUpdatesEvent"]
+    }
+
+    public override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    // MARK: - Module Constants
+
+    public override func constantsToExport() -> [AnyHashable: Any]! {
+        return PulseUpdates.buildState()
+    }
+
+    // MARK: - Configuration
+
+    @objc
+    func configure(
+        _ enabled: Bool,
+        updateUrl: String,
+        runtimeVersion: String,
+        checkOnLaunch: String,
+        launchWaitMs: Int,
+        channel: String?,
+        signingKeyId: String?,
+        signingPublicKey: String?
+    ) {
+        let config = PulseUpdatesConfig(
+            enabled: enabled,
+            updateUrl: updateUrl,
+            runtimeVersion: runtimeVersion.isEmpty ? Self.nativeRuntimeVersion() : runtimeVersion,
+            checkOnLaunch: checkOnLaunch,
+            launchWaitMs: launchWaitMs,
+            channel: channel,
+            signingKeyId: signingKeyId,
+            signingPublicKey: signingPublicKey
+        )
+
+        PulseController.shared.configure(config)
+        PulseController.shared.start()
+
+        pulseLog("Configured enabled=\(enabled) url=\(updateUrl) runtime=\(config.runtimeVersion)")
+    }
+
+    // MARK: - Get State
+
+    @objc
+    func getStateAsync(_ resolve: @escaping RCTPromiseResolveBlock,
+                       reject: @escaping RCTPromiseRejectBlock) {
+        resolve(PulseUpdates.buildState())
+    }
+
+    private static func buildState() -> [String: Any] {
+        let controller = PulseController.shared
+
+        // Match expo-updates constants structure
+        var state: [String: Any] = [
+            "isEnabled": controller.config?.enabled ?? false,
+            "isEmbeddedLaunch": controller.isEmbeddedLaunch,
+            // expo-updates calls this isUsingEmbeddedAssets
+            "isUsingEmbeddedAssets": controller.isEmbeddedLaunch,
+            "runtimeVersion": controller.config?.runtimeVersion ?? nativeRuntimeVersion()
+        ]
+
+        if let updateId = controller.launchedUpdate?.updateId {
+            state["updateId"] = updateId
+        } else {
+            state["updateId"] = NSNull()
+        }
+
+        state["channel"] = controller.config?.channel ?? NSNull()
+
+        // Return manifest JSON string for metadata (build number, etc.)
+        // expo-updates returns this as 'manifest' in native constants
+        if let manifestJson = controller.launchedManifestJson {
+            state["manifestString"] = manifestJson
+        } else {
+            state["manifestString"] = NSNull()
+        }
+
+        if let commitTime = controller.launchedUpdate?.commitTime {
+            state["commitTime"] = commitTime.timeIntervalSince1970 * 1000
+        } else {
+            state["commitTime"] = NSNull()
+        }
+
+        // Local assets map for expo-asset compatibility
+        // Key: asset key from manifest, Value: local file:// URL
+        // expo-updates exposes this as localAssets
+        state["localAssets"] = controller.localAssets.isEmpty ? [:] : controller.localAssets
+
+        return state
+    }
+
+    // MARK: - Check for Update
+
+    @objc
+    func checkForUpdateAsync(_ resolve: @escaping RCTPromiseResolveBlock,
+                             reject: @escaping RCTPromiseRejectBlock) {
+        PulseController.shared.checkForUpdate { result in
+            switch result {
+            case .success(let checkResult):
+                var response: [String: Any] = [
+                    "isAvailable": checkResult.isAvailable
+                ]
+
+                if let manifest = checkResult.manifest,
+                   let data = try? JSONEncoder().encode(manifest),
+                   let string = String(data: data, encoding: .utf8) {
+                    response["manifestString"] = string
+                }
+
+                if checkResult.isRollback {
+                    response["isRollback"] = true
+                    response["failedReason"] = checkResult.failedReason ?? "Unknown"
+                }
+
+                resolve(response)
+
+            case .failure(let error):
+                reject("E_CHECK_UPDATE", error.localizedDescription, error)
+            }
+        }
+    }
+
+    // MARK: - Fetch Update
+
+    @objc
+    func fetchUpdateAsync(_ resolve: @escaping RCTPromiseResolveBlock,
+                          reject: @escaping RCTPromiseRejectBlock) {
+        PulseController.shared.fetchUpdate { result in
+            switch result {
+            case .success(let fetchResult):
+                var response: [String: Any] = [
+                    "isNew": fetchResult.isNew
+                ]
+
+                if let manifest = fetchResult.manifest,
+                   let data = try? JSONEncoder().encode(manifest),
+                   let string = String(data: data, encoding: .utf8) {
+                    response["manifestString"] = string
+                }
+
+                resolve(response)
+
+            case .failure(let error):
+                reject("E_FETCH_UPDATE", error.localizedDescription, error)
+            }
+        }
+    }
+
+    // MARK: - Reload
+
+    @objc
+    func reloadAsync(_ resolve: @escaping RCTPromiseResolveBlock,
+                     reject: @escaping RCTPromiseRejectBlock) {
+        pulseLog("reloadAsync BEFORE launchAssetUrl=\(PulseController.shared.launchAssetUrl?.lastPathComponent ?? "nil")")
+
+        // Re-select the best update, then trigger reload
+        PulseController.shared.reload { success in
+            let newBundleUrl = PulseController.shared.launchAssetUrl
+            pulseLog("reloadAsync AFTER success=\(success) launchAssetUrl=\(newBundleUrl?.lastPathComponent ?? "nil")")
+
+            DispatchQueue.main.async {
+                // Set new bundle URL before triggering reload - like expo-updates does
+                if let bundleUrl = newBundleUrl {
+                    RCTReloadCommandSetBundleURL(bundleUrl)
+                }
+                RCTTriggerReloadCommandListeners("PulseUpdates reload")
+                resolve(nil)
+            }
+        }
+    }
+
+    // MARK: - Health
+
+    @objc
+    func markAppReady(_ resolve: @escaping RCTPromiseResolveBlock,
+                      reject: @escaping RCTPromiseRejectBlock) {
+        PulseController.shared.markAppReady()
+        resolve(nil)
+    }
+
+    @objc
+    func reportLaunchFailure(_ reason: String,
+                             resolve: @escaping RCTPromiseResolveBlock,
+                             reject: @escaping RCTPromiseRejectBlock) {
+        let error = NSError(domain: "PulseUpdates", code: -1, userInfo: [NSLocalizedDescriptionKey: reason])
+        PulseController.shared.reportError(error)
+        resolve(nil)
+    }
+
+    // MARK: - Get Bundle URL
+
+    @objc
+    public static func getBundleURL() -> URL? {
+        // If controller hasn't started yet, start it now
+        if !PulseController.shared.isStarted {
+            PulseController.shared.initializeWithoutStarting()
+        }
+
+        let url = PulseController.shared.launchAssetURL()
+        pulseLog("getBundleURL isStarted=\(PulseController.shared.isStarted) url=\(url?.lastPathComponent ?? "nil")")
+        return url
+    }
+
+    // MARK: - Helpers
+
+    private static func nativeRuntimeVersion() -> String {
+        let info = Bundle.main.infoDictionary
+        return (info?["CFBundleShortVersionString"] as? String)
+            ?? (info?["CFBundleVersion"] as? String)
+            ?? "unknown"
+    }
+
+    // MARK: - Event Emission
+
+    private func sendEvent(type: PulseUpdatesEventType, body: [String: Any]? = nil) {
+        var event: [String: Any] = ["type": type.rawValue]
+        if let body = body {
+            event["body"] = body
+        }
+        sendEvent(withName: "PulseUpdatesEvent", body: event)
+    }
+}

package/lib/commonjs/NativePulseUpdates.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.get('PulseUpdates');
+//# sourceMappingURL=NativePulseUpdates.js.map

package/lib/commonjs/NativePulseUpdates.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","get"],"sourceRoot":"../../src","sources":["NativePulseUpdates.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAkDpCC,gCAAmB,CAACC,GAAG,CAAO,cAAc,CAAC","ignoreList":[]}