native-update 1.0.0

package/docs/server-requirements.md

@@ -0,0 +1,147 @@
+# Backend Server Requirements
+
+This document outlines the server infrastructure you need to build to use this plugin.
+
+## ⚠️ No Server Included
+
+This plugin does **not** include a backend server. You must build your own server that implements these requirements.
+
+## Required API Endpoints
+
+### 1. Version Check Endpoint
+```
+GET /api/v1/updates/check
+```
+
+**Query Parameters:**
+- `appId`: Your application ID
+- `currentVersion`: Current bundle version
+- `platform`: ios | android | web
+- `channel`: production | staging | development
+
+**Response:**
+```json
+{
+  "updateAvailable": true,
+  "version": "1.2.3",
+  "minAppVersion": "2.0.0",
+  "releaseNotes": "Bug fixes and improvements",
+  "downloadUrl": "https://cdn.example.com/bundles/1.2.3.zip",
+  "signature": "base64-encoded-signature",
+  "checksum": "sha256-hash",
+  "size": 1234567,
+  "mandatory": false
+}
+```
+
+### 2. Bundle Download Endpoint
+```
+GET /api/v1/bundles/{version}
+```
+
+**Requirements:**
+- Serve bundle files with proper MIME types
+- Support resume/partial downloads
+- Include security headers
+- CDN integration recommended
+
+### 3. Update Confirmation Endpoint
+```
+POST /api/v1/updates/confirm
+```
+
+**Body:**
+```json
+{
+  "appId": "com.example.app",
+  "version": "1.2.3",
+  "platform": "ios",
+  "success": true,
+  "deviceId": "unique-device-id"
+}
+```
+
+## Security Requirements
+
+### Bundle Signing
+- Generate RSA or ECDSA key pairs
+- Sign bundles with private key
+- Include public key in app
+- Verify signatures before applying updates
+
+### HTTPS Requirements
+- All endpoints must use HTTPS
+- Consider certificate pinning
+- Implement rate limiting
+- Add authentication tokens
+
+## Storage Infrastructure
+
+### Bundle Storage
+- Store bundle files securely
+- Implement versioning system
+- Clean up old versions
+- Monitor storage usage
+
+### CDN Configuration
+- Geographic distribution
+- Caching strategies
+- Bandwidth optimization
+- Fallback mechanisms
+
+## Example Server Structure
+
+```
+update-server/
+├── src/
+│   ├── api/
+│   │   ├── updates.js
+│   │   ├── bundles.js
+│   │   └── analytics.js
+│   ├── services/
+│   │   ├── signing.js
+│   │   ├── storage.js
+│   │   └── version.js
+│   ├── middleware/
+│   │   ├── auth.js
+│   │   ├── security.js
+│   │   └── logging.js
+│   └── config/
+│       └── index.js
+├── bundles/
+│   └── [stored bundle files]
+├── keys/
+│   ├── private.pem
+│   └── public.pem
+└── package.json
+```
+
+## Minimum Implementation Checklist
+
+- [ ] Version check API endpoint
+- [ ] Bundle download endpoint
+- [ ] Bundle signing implementation
+- [ ] HTTPS configuration
+- [ ] Basic authentication
+- [ ] Error handling
+- [ ] Logging system
+- [ ] Health check endpoint
+
+## Recommended Features
+
+- [ ] Analytics tracking
+- [ ] A/B testing support
+- [ ] Rollback capabilities
+- [ ] Multi-tenant support
+- [ ] Admin dashboard
+- [ ] Monitoring/alerting
+- [ ] Automated testing
+
+## Getting Help
+
+Since no server is provided, you'll need to:
+1. Build your own implementation
+2. Use a third-party service
+3. Hire developers familiar with update servers
+
+Consider looking at open-source examples or commercial solutions for inspiration.

package/ios/Plugin/AppReview/AppReviewPlugin.swift

@@ -0,0 +1,158 @@
+import Foundation
+import Capacitor
+import StoreKit
+
+class AppReviewPlugin {
+    private weak var plugin: CAPPlugin?
+    private var config: [String: Any]?
+    private let userDefaults = UserDefaults.standard
+    
+    private struct Keys {
+        static let installDate = "native_update_review_install_date"
+        static let lastReviewRequest = "native_update_review_last_request"
+        static let launchCount = "native_update_review_launch_count"
+        static let reviewShownCount = "native_update_review_shown_count"
+    }
+    
+    init(plugin: CAPPlugin) {
+        self.plugin = plugin
+        
+        // Initialize install date if not set
+        if userDefaults.object(forKey: Keys.installDate) == nil {
+            userDefaults.set(Date(), forKey: Keys.installDate)
+        }
+        
+        // Increment launch count
+        incrementLaunchCount()
+    }
+    
+    func configure(_ config: [String: Any]) throws {
+        self.config = config
+    }
+    
+    func requestReview(_ call: CAPPluginCall) {
+        // First check if we can request a review
+        let (allowed, reason) = checkCanRequestReview()
+        
+        if !allowed {
+            call.resolve([
+                "shown": false,
+                "error": reason ?? "Review conditions not met"
+            ])
+            return
+        }
+        
+        // Request review using StoreKit
+        DispatchQueue.main.async { [weak self] in
+            if #available(iOS 14.0, *) {
+                if let windowScene = UIApplication.shared.connectedScenes
+                    .first(where: { $0.activationState == .foregroundActive }) as? UIWindowScene {
+                    SKStoreReviewController.requestReview(in: windowScene)
+                    self?.updateReviewRequestTime()
+                    
+                    call.resolve([
+                        "shown": true
+                    ])
+                } else {
+                    call.resolve([
+                        "shown": false,
+                        "error": "No active window scene found"
+                    ])
+                }
+            } else {
+                // Fallback for iOS 13 and earlier
+                SKStoreReviewController.requestReview()
+                self?.updateReviewRequestTime()
+                
+                call.resolve([
+                    "shown": true
+                ])
+            }
+        }
+    }
+    
+    func canRequestReview(_ call: CAPPluginCall) {
+        let (allowed, reason) = checkCanRequestReview()
+        
+        var result: [String: Any] = ["allowed": allowed]
+        if !allowed, let reason = reason {
+            result["reason"] = reason
+        }
+        
+        call.resolve(result)
+    }
+    
+    // MARK: - Private Methods
+    
+    private func checkCanRequestReview() -> (Bool, String?) {
+        // Check if debug mode is enabled
+        let debugMode = config?["debugMode"] as? Bool ?? false
+        if debugMode {
+            return (true, nil)
+        }
+        
+        let now = Date()
+        let installDate = userDefaults.object(forKey: Keys.installDate) as? Date ?? now
+        let lastReviewRequest = userDefaults.object(forKey: Keys.lastReviewRequest) as? Date
+        let launchCount = userDefaults.integer(forKey: Keys.launchCount)
+        let shownCount = userDefaults.integer(forKey: Keys.reviewShownCount)
+        
+        // Check minimum days since install
+        let minDaysSinceInstall = config?["minimumDaysSinceInstall"] as? Int ?? 7
+        let daysSinceInstall = Calendar.current.dateComponents([.day], from: installDate, to: now).day ?? 0
+        if daysSinceInstall < minDaysSinceInstall {
+            return (false, "Not enough days since install")
+        }
+        
+        // Check minimum days since last prompt
+        if let lastRequest = lastReviewRequest {
+            let minDaysSinceLastPrompt = config?["minimumDaysSinceLastPrompt"] as? Int ?? 90
+            let daysSinceLastPrompt = Calendar.current.dateComponents([.day], from: lastRequest, to: now).day ?? 0
+            if daysSinceLastPrompt < minDaysSinceLastPrompt {
+                return (false, "Too soon since last review request")
+            }
+        }
+        
+        // Check minimum launch count
+        let minLaunchCount = config?["minimumLaunchCount"] as? Int ?? 3
+        if launchCount < minLaunchCount {
+            return (false, "Not enough app launches")
+        }
+        
+        // iOS limits to 3 review requests per year
+        if shownCount >= 3 {
+            // Check if it's been a year since the first request
+            if let firstRequestDate = userDefaults.object(forKey: "native_update_review_first_request") as? Date {
+                let daysSinceFirst = Calendar.current.dateComponents([.day], from: firstRequestDate, to: now).day ?? 0
+                if daysSinceFirst < 365 {
+                    return (false, "Review quota exceeded")
+                } else {
+                    // Reset count after a year
+                    userDefaults.set(0, forKey: Keys.reviewShownCount)
+                    userDefaults.removeObject(forKey: "native_update_review_first_request")
+                }
+            }
+        }
+        
+        return (true, nil)
+    }
+    
+    private func incrementLaunchCount() {
+        let currentCount = userDefaults.integer(forKey: Keys.launchCount)
+        userDefaults.set(currentCount + 1, forKey: Keys.launchCount)
+    }
+    
+    private func updateReviewRequestTime() {
+        let now = Date()
+        userDefaults.set(now, forKey: Keys.lastReviewRequest)
+        
+        // Track first request for yearly quota
+        if userDefaults.object(forKey: "native_update_review_first_request") == nil {
+            userDefaults.set(now, forKey: "native_update_review_first_request")
+        }
+        
+        // Increment shown count
+        let shownCount = userDefaults.integer(forKey: Keys.reviewShownCount)
+        userDefaults.set(shownCount + 1, forKey: Keys.reviewShownCount)
+    }
+}

package/ios/Plugin/AppUpdate/AppUpdatePlugin.swift

@@ -0,0 +1,234 @@
+import Foundation
+import Capacitor
+import UIKit
+
+class AppUpdatePlugin {
+    private weak var plugin: CAPPlugin?
+    private var config: [String: Any]?
+    private let iTunesLookupURL = "https://itunes.apple.com/lookup"
+    
+    init(plugin: CAPPlugin) {
+        self.plugin = plugin
+    }
+    
+    func configure(_ config: [String: Any]) throws {
+        self.config = config
+    }
+    
+    func getAppUpdateInfo(_ call: CAPPluginCall) {
+        Task {
+            do {
+                let bundleId = Bundle.main.bundleIdentifier ?? ""
+                let currentVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.0.0"
+                
+                // Check iTunes for app info
+                let appInfo = try await checkAppStoreVersion(bundleId: bundleId)
+                
+                let storeVersion = appInfo["version"] as? String ?? "0.0.0"
+                let updateAvailable = isVersionNewer(storeVersion, than: currentVersion)
+                
+                var result: [String: Any] = [
+                    "updateAvailable": updateAvailable,
+                    "currentVersion": currentVersion
+                ]
+                
+                if updateAvailable {
+                    result["availableVersion"] = storeVersion
+                    
+                    // Calculate staleness in days
+                    if let releaseDate = appInfo["currentVersionReleaseDate"] as? String {
+                        let formatter = ISO8601DateFormatter()
+                        if let date = formatter.date(from: releaseDate) {
+                            let days = Calendar.current.dateComponents([.day], from: date, to: Date()).day ?? 0
+                            result["clientVersionStalenessDays"] = days
+                        }
+                    }
+                }
+                
+                // iOS doesn't have the same update types as Android
+                result["immediateUpdateAllowed"] = false
+                result["flexibleUpdateAllowed"] = false
+                
+                // Check minimum version requirement
+                if let minimumVersion = config?["minimumVersion"] as? String {
+                    let needsUpdate = isVersionNewer(minimumVersion, than: currentVersion)
+                    if needsUpdate {
+                        result["updatePriority"] = 5 // High priority
+                    }
+                }
+                
+                call.resolve(result)
+            } catch {
+                call.reject("UPDATE_CHECK_FAILED", error.localizedDescription)
+            }
+        }
+    }
+    
+    func performImmediateUpdate(_ call: CAPPluginCall) {
+        // iOS doesn't support in-app updates like Android
+        // We'll open the App Store instead
+        openAppStore(call)
+    }
+    
+    func startFlexibleUpdate(_ call: CAPPluginCall) {
+        // iOS doesn't support flexible updates
+        call.reject("PLATFORM_NOT_SUPPORTED", "Flexible updates are not supported on iOS")
+    }
+    
+    func completeFlexibleUpdate(_ call: CAPPluginCall) {
+        // iOS doesn't support flexible updates
+        call.reject("PLATFORM_NOT_SUPPORTED", "Flexible updates are not supported on iOS")
+    }
+    
+    func openAppStore(_ call: CAPPluginCall) {
+        let appId = call.getString("appId") ?? getAppStoreId()
+        
+        guard let appId = appId else {
+            call.reject("APP_ID_REQUIRED", "App ID is required to open App Store")
+            return
+        }
+        
+        let urlString = "itms-apps://apple.com/app/id\(appId)"
+        
+        DispatchQueue.main.async {
+            if let url = URL(string: urlString),
+               UIApplication.shared.canOpenURL(url) {
+                UIApplication.shared.open(url, options: [:]) { success in
+                    if success {
+                        call.resolve()
+                    } else {
+                        // Fallback to web URL
+                        if let webUrl = URL(string: "https://apps.apple.com/app/id\(appId)") {
+                            UIApplication.shared.open(webUrl, options: [:]) { webSuccess in
+                                if webSuccess {
+                                    call.resolve()
+                                } else {
+                                    call.reject("OPEN_STORE_FAILED", "Failed to open App Store")
+                                }
+                            }
+                        } else {
+                            call.reject("OPEN_STORE_FAILED", "Failed to open App Store")
+                        }
+                    }
+                }
+            } else {
+                call.reject("INVALID_URL", "Invalid App Store URL")
+            }
+        }
+    }
+    
+    // MARK: - Async Methods for Background Updates
+    
+    func getAppUpdateInfoAsync() async -> AppUpdateInfo? {
+        do {
+            let bundleId = Bundle.main.bundleIdentifier ?? ""
+            let currentVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.0.0"
+            
+            // Check iTunes for app info
+            let appInfo = try await checkAppStoreVersion(bundleId: bundleId)
+            
+            let storeVersion = appInfo["version"] as? String ?? "0.0.0"
+            let updateAvailable = isVersionNewer(storeVersion, than: currentVersion)
+            
+            return AppUpdateInfo(
+                updateAvailable: updateAvailable,
+                currentVersion: currentVersion,
+                availableVersion: updateAvailable ? storeVersion : nil
+            )
+        } catch {
+            NSLog("Failed to check app update: \(error.localizedDescription)")
+            return nil
+        }
+    }
+    
+    // MARK: - Private Methods
+    
+    private func checkAppStoreVersion(bundleId: String) async throws -> [String: Any] {
+        guard let countryCode = Locale.current.regionCode else {
+            throw NSError(domain: "AppUpdatePlugin", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "Could not determine country code"
+            ])
+        }
+        
+        var components = URLComponents(string: iTunesLookupURL)!
+        components.queryItems = [
+            URLQueryItem(name: "bundleId", value: bundleId),
+            URLQueryItem(name: "country", value: countryCode)
+        ]
+        
+        guard let url = components.url else {
+            throw NSError(domain: "AppUpdatePlugin", code: 2, userInfo: [
+                NSLocalizedDescriptionKey: "Invalid iTunes lookup URL"
+            ])
+        }
+        
+        let (data, _) = try await URLSession.shared.data(from: url)
+        
+        guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let results = json["results"] as? [[String: Any]],
+              let appInfo = results.first else {
+            throw NSError(domain: "AppUpdatePlugin", code: 3, userInfo: [
+                NSLocalizedDescriptionKey: "No app found in App Store"
+            ])
+        }
+        
+        return appInfo
+    }
+    
+    private func isVersionNewer(_ version1: String, than version2: String) -> Bool {
+        let v1Components = version1.split(separator: ".").compactMap { Int($0) }
+        let v2Components = version2.split(separator: ".").compactMap { Int($0) }
+        
+        let maxCount = max(v1Components.count, v2Components.count)
+        
+        for i in 0..<maxCount {
+            let v1 = i < v1Components.count ? v1Components[i] : 0
+            let v2 = i < v2Components.count ? v2Components[i] : 0
+            
+            if v1 > v2 {
+                return true
+            } else if v1 < v2 {
+                return false
+            }
+        }
+        
+        return false
+    }
+    
+    private func getAppStoreId() -> String? {
+        // Try to get from config first
+        if let storeUrl = (config?["storeUrl"] as? [String: Any])?["ios"] as? String {
+            // Extract ID from URL like https://apps.apple.com/app/id123456789
+            let pattern = #"id(\d+)"#
+            if let regex = try? NSRegularExpression(pattern: pattern),
+               let match = regex.firstMatch(in: storeUrl, range: NSRange(storeUrl.startIndex..., in: storeUrl)) {
+                let range = Range(match.range(at: 1), in: storeUrl)!
+                return String(storeUrl[range])
+            }
+        }
+        
+        // Try to get from Info.plist
+        return Bundle.main.infoDictionary?["AppStoreId"] as? String
+    }
+}
+
+// MARK: - Data Models
+
+struct AppUpdateInfo {
+    let updateAvailable: Bool
+    let currentVersion: String
+    let availableVersion: String?
+    
+    func toDictionary() -> [String: Any] {
+        var obj: [String: Any] = [
+            "updateAvailable": updateAvailable,
+            "currentVersion": currentVersion
+        ]
+        
+        if let availableVersion = availableVersion {
+            obj["availableVersion"] = availableVersion
+        }
+        
+        return obj
+    }
+}