react-native-stallion 1.1.2 → 2.0.0-alpha.2

package/ios/main/StallionExceptionHandler.m

@@ -0,0 +1,94 @@
+//
+//  StallionExceptionHandler.m
+//  react-native-stallion
+//
+//  Created by Jasbir Singh Shergill on 29/01/25.
+//
+
+#import "StallionExceptionHandler.h"
+#import "StallionStateManager.h"
+#import "StallionEventHandler.h"
+#import "StallionSlotManager.h"
+#import "StallionMeta.h"
+#import "StallionMetaConstants.h"
+#import "StallionObjConstants.h"
+
+@implementation StallionExceptionHandler
+
+NSUncaughtExceptionHandler *_defaultExceptionHandler;
+
++ (void)initExceptionHandler {
+    if (!_defaultExceptionHandler) {
+        _defaultExceptionHandler = NSGetUncaughtExceptionHandler();
+    }
+    NSSetUncaughtExceptionHandler(&handleException);
+}
+
+BOOL exceptionAlertDismissed = FALSE;
+
+void handleException(NSException *exception) {
+    StallionStateManager *stateManager = [StallionStateManager sharedInstance];
+    StallionMeta *meta = stateManager.stallionMeta;
+    BOOL isAutoRollback = !stateManager.isMounted;
+
+    NSString *readableError = [exception reason];
+  
+  if (readableError.length > 900) {
+      readableError = [readableError substringToIndex:900];
+  }
+
+  if (meta.switchState == SwitchStateProd) {
+    NSString *currentHash = [meta getActiveReleaseHash] ?: @"";
+
+    [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_prod_event
+          eventPayload:@{
+              @"meta": readableError,
+              StallionObjConstants.release_hash_key: currentHash,
+              StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+          }];
+        if (isAutoRollback) {
+            [StallionSlotManager rollbackProdWithAutoRollback:YES errorString:readableError];
+        }
+
+  } else if (meta.switchState == SwitchStateStage) {
+        [StallionSlotManager rollbackStage];
+    
+    [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_stage_event
+          eventPayload:@{
+              @"meta": readableError,
+              StallionObjConstants.release_hash_key: meta.stageNewHash,
+              StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+          }];
+
+        UIAlertController *alert = [UIAlertController alertControllerWithTitle:@"Stallion Exception Handler"
+           message:[NSString stringWithFormat:@"%@\n%@",
+                    @"A crash occurred in the app. Build was rolled back. Check crash report below. Continue crash to invoke other exception handlers. \n \n",
+                    readableError]
+          preferredStyle:UIAlertControllerStyleAlert];
+
+        [alert addAction:[UIAlertAction actionWithTitle:@"Continue Crash"
+                                                  style:UIAlertActionStyleDefault
+                                                handler:^(UIAlertAction *action) {
+                                                    exceptionAlertDismissed = TRUE;
+                                                }]];
+
+        UIApplication *app = [UIApplication sharedApplication];
+        UIViewController *rootViewController = app.delegate.window.rootViewController;
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [rootViewController presentViewController:alert animated:YES completion:nil];
+        });
+
+        while (exceptionAlertDismissed == FALSE) {
+            [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+        }
+    }
+
+    // Call default exception handler if available
+    if (_defaultExceptionHandler) {
+        _defaultExceptionHandler(exception);
+    }
+}
+
+@end
+

package/ios/main/StallionFileDownloader.swift

@@ -0,0 +1,147 @@
+//
+//  StallionFileDownloader.swift
+//  react-native-stallion
+//
+//  Updated by Thor963 on 17/05/23.
+//
+
+import Foundation
+import ZIPFoundation
+
+class StallionFileDownloader: NSObject {
+    private lazy var urlSession = URLSession(configuration: .default,
+                                             delegate: self,
+                                             delegateQueue: nil)
+    private var downloadTask: URLSessionDownloadTask?
+    private var _resolve: RCTPromiseResolveBlock?
+    private var _reject: RCTPromiseRejectBlock?
+    private var _onProgress: ((Float) -> Void)?
+    private var lastSentProgress: Float = 0
+    private var _downloadDirectory: String?
+    
+    private let queue = DispatchQueue(label: "com.stallion.networkmanager", qos: .background)
+
+    override init() {
+        super.init()
+    }
+
+    func downloadBundle(url: URL, downloadDirectory: String, onProgress: @escaping ((Float) -> Void), resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        queue.async {
+            do {
+                self._resolve = resolve
+                self._reject = reject
+                self._onProgress = onProgress
+                self._downloadDirectory = downloadDirectory
+                
+                // Prepare for download
+                let downloadedZip = try self.prepareForDownload(downloadDirectory: downloadDirectory)
+                
+                // Create request
+                var request = URLRequest(url: url)
+                request.httpMethod = "GET"
+              
+                let appToken = StallionStateManager.sharedInstance().stallionConfig.appToken ?? ""
+                let sdkToken = StallionStateManager.sharedInstance().stallionConfig.sdkToken ?? ""
+                
+                if !appToken.isEmpty {
+                    request.setValue(appToken, forHTTPHeaderField: StallionConstants.STALLION_APP_TOKEN_KEY)
+                }
+                if !sdkToken.isEmpty {
+                    request.setValue(sdkToken, forHTTPHeaderField: StallionConstants.STALLION_SDK_TOKEN_KEY)
+                }
+                
+                // Initiate download
+                self.downloadTask = self.urlSession.downloadTask(with: request)
+                self.downloadTask?.resume()
+                
+            } catch {
+                reject("500", "Error preparing for download: \(error.localizedDescription)", error as NSError)
+            }
+        }
+    }
+    
+    private func prepareForDownload(downloadDirectory: String) throws -> URL {
+        let downloadFolder = URL(fileURLWithPath: downloadDirectory, isDirectory: true)
+        let fileManager = FileManager.default
+        
+        // Delete existing folder if it exists
+        if fileManager.fileExists(atPath: downloadFolder.path) {
+            try fileManager.removeItem(at: downloadFolder)
+        }
+        
+        // Create new download folder
+        try fileManager.createDirectory(at: downloadFolder, withIntermediateDirectories: true, attributes: nil)
+        
+        // Return path to zip file
+        return downloadFolder.appendingPathComponent(StallionConstants.FilePaths.ZipFolderName).appendingPathExtension(StallionConstants.FilePaths.ZipExtension)
+    }
+    
+    private func validateAndUnzip(downloadedZip: URL, destDirectory: String) throws {
+        let fileManager = FileManager.default
+        let destFolder = URL(fileURLWithPath: destDirectory, isDirectory: true)
+      let otaBundle = destFolder.appendingPathComponent(StallionConstants.FilePaths.ZipFolderName).appendingPathComponent(StallionConstants.FilePaths.JSFileName)
+        
+        // Validate the ZIP file
+        guard try isValidZip(downloadedZip: downloadedZip) else {
+            throw NSError(domain: "Invalid ZIP file", code: 500)
+        }
+        
+        // Unzip the file
+        try fileManager.unzipItem(at: downloadedZip, to: destFolder)
+        
+        // Verify that the extracted bundle exists
+        guard fileManager.fileExists(atPath: otaBundle.path) else {
+            throw NSError(domain: "Corrupted file error", code: 500)
+        }
+        
+        // Clean up the ZIP file
+        try fileManager.removeItem(at: downloadedZip)
+        
+        self._resolve?(StallionConstants.DownloadPromiseResponses.Success)
+    }
+    
+    private func isValidZip(downloadedZip: URL) throws -> Bool {
+        let headerSize = 4
+        
+        guard let inputStream = InputStream(url: downloadedZip) else {
+            throw NSError(domain: "Cannot open ZIP file", code: 500)
+        }
+        
+        inputStream.open()
+        defer { inputStream.close() }
+        
+        var header = [UInt8](repeating: 0, count: headerSize)
+        let bytesRead = inputStream.read(&header, maxLength: headerSize)
+        
+        guard bytesRead == headerSize else { return false }
+        return header == [0x50, 0x4B, 0x03, 0x04] // PKZIP magic number
+    }
+}
+
+extension StallionFileDownloader: URLSessionDownloadDelegate {
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
+        let progress = Float(totalBytesWritten) / Float(totalBytesExpectedToWrite)
+      if progress - self.lastSentProgress > StallionConstants.PROGRESS_EVENT_THRESHOLD {
+            self.lastSentProgress = progress
+            self._onProgress?(progress)
+        }
+    }
+    
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        do {
+          if let downloadDirectory = self._downloadDirectory {
+            try self.validateAndUnzip(downloadedZip: location, destDirectory: downloadDirectory)
+          } else {
+            throw NSError(domain: "Destination folder not found while unzipping", code: 500)
+          }
+        } catch {
+            self._reject?("500", "File validation/unzipping failed: \(error.localizedDescription)", error as NSError)
+        }
+    }
+    
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        if let error = error {
+            self._reject?("500", "Network error: \(error.localizedDescription)", error as NSError)
+        }
+    }
+}

package/ios/main/StallionFileManager.h

@@ -0,0 +1,20 @@
+//
+//  StallionFileManager.h
+//  react-native-stallion
+//
+//  Created by Jasbir Singh Shergill on 29/01/25.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface StallionFileManager : NSObject
+
++ (void)deleteFileOrFolderSilently:(NSString *)filePath;
++ (void)moveFileFrom:(NSString *)fromPath to:(NSString *)toPath;
++ (void)copyFileOrDirectoryFrom:(NSString *)sourcePath to:(NSString *)destinationPath;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/main/StallionFileManager.m

@@ -0,0 +1,126 @@
+//
+//  StallionFileManager.m
+//  react-native-stallion
+//
+//  Created by Jasbir Singh Shergill on 29/01/25.
+//
+#import "StallionFileManager.h"
+
+@implementation StallionFileManager
+
++ (void)deleteFileOrFolderSilently:(NSString *)filePath {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSError *error = nil;
+    BOOL isDirectory = NO;
+
+    if ([fileManager fileExistsAtPath:filePath isDirectory:&isDirectory]) {
+        if (isDirectory) {
+            NSArray *contents = [fileManager contentsOfDirectoryAtPath:filePath error:&error];
+            if (error) {
+                NSLog(@"Failed to list contents of directory: %@", error.localizedDescription);
+                return;
+            }
+            for (NSString *content in contents) {
+                NSString *fullPath = [filePath stringByAppendingPathComponent:content];
+                [self deleteFileOrFolderSilently:fullPath];
+            }
+        }
+        if (![fileManager removeItemAtPath:filePath error:&error]) {
+            NSLog(@"Failed to delete file or folder: %@", error.localizedDescription);
+        }
+    }
+}
+
++ (void)moveFileFrom:(NSString *)fromPath to:(NSString *)toPath {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSError *error = nil;
+
+    // Ensure destination directory exists
+    NSString *destinationDirectory = [toPath stringByDeletingLastPathComponent];
+    if (![fileManager fileExistsAtPath:destinationDirectory]) {
+        if (![fileManager createDirectoryAtPath:destinationDirectory
+                     withIntermediateDirectories:YES
+                                      attributes:nil
+                                           error:&error]) {
+            NSLog(@"Failed to create destination directory: %@", error.localizedDescription);
+            return;
+        }
+    }
+
+    // Attempt to move the file
+    if ([fileManager fileExistsAtPath:toPath]) {
+        [self deleteFileOrFolderSilently:toPath];
+    }
+
+    if (![fileManager moveItemAtPath:fromPath toPath:toPath error:&error]) {
+        NSLog(@"Failed to move file: %@", error.localizedDescription);
+        // Fallback: Copy the file and delete the original
+        [self copyFileOrDirectoryFrom:fromPath to:toPath];
+        [self deleteFileOrFolderSilently:fromPath];
+    }
+}
+
++ (void)copyFileOrDirectoryFrom:(NSString *)sourcePath to:(NSString *)destinationPath {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSError *error = nil;
+
+    BOOL isDirectory = NO;
+    if (![fileManager fileExistsAtPath:sourcePath isDirectory:&isDirectory]) {
+        NSLog(@"Source does not exist: %@", sourcePath);
+        return;
+    }
+
+    if (isDirectory) {
+        // Copy directory recursively
+        [self copyDirectoryFrom:sourcePath to:destinationPath];
+    } else {
+        // Copy individual file
+        if (![fileManager copyItemAtPath:sourcePath toPath:destinationPath error:&error]) {
+            NSLog(@"Failed to copy file: %@", error.localizedDescription);
+        }
+    }
+}
+
+#pragma mark - Private Helper Methods
+
++ (void)copyDirectoryFrom:(NSString *)sourceDirectory to:(NSString *)destinationDirectory {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSError *error = nil;
+
+    // Ensure destination directory exists
+    if (![fileManager fileExistsAtPath:destinationDirectory]) {
+        if (![fileManager createDirectoryAtPath:destinationDirectory
+                     withIntermediateDirectories:YES
+                                      attributes:nil
+                                           error:&error]) {
+            NSLog(@"Failed to create destination directory: %@", error.localizedDescription);
+            return;
+        }
+    }
+
+    NSArray *contents = [fileManager contentsOfDirectoryAtPath:sourceDirectory error:&error];
+    if (error) {
+        NSLog(@"Failed to list contents of directory: %@", error.localizedDescription);
+        return;
+    }
+
+    for (NSString *content in contents) {
+        NSString *sourcePath = [sourceDirectory stringByAppendingPathComponent:content];
+        NSString *destinationPath = [destinationDirectory stringByAppendingPathComponent:content];
+        BOOL isDirectory = NO;
+
+        if ([fileManager fileExistsAtPath:sourcePath isDirectory:&isDirectory]) {
+            if (isDirectory) {
+                // Recursively copy subdirectories
+                [self copyDirectoryFrom:sourcePath to:destinationPath];
+            } else {
+                // Copy individual file
+                if (![fileManager copyItemAtPath:sourcePath toPath:destinationPath error:&error]) {
+                    NSLog(@"Failed to copy file: %@", error.localizedDescription);
+                }
+            }
+        }
+    }
+}
+
+@end

package/ios/main/StallionMeta.h

@@ -0,0 +1,29 @@
+//
+//  StallionMeta.h
+//  DoubleConversion
+//
+//  Created by Jasbir Singh Shergill on 28/01/25.
+//
+
+#import <Foundation/Foundation.h>
+#import "StallionMetaConstants.h"
+
+@interface StallionMeta : NSObject
+
+@property (nonatomic, assign) SwitchState switchState;
+@property (nonatomic, assign) SlotStates currentProdSlot;
+@property (nonatomic, assign) SlotStates currentStageSlot;
+
+@property (nonatomic, copy) NSString *stageTempHash;
+@property (nonatomic, copy) NSString *stageNewHash;
+@property (nonatomic, copy) NSString *prodTempHash;
+@property (nonatomic, copy) NSString *prodNewHash;
+@property (nonatomic, copy) NSString *prodStableHash;
+@property (nonatomic, copy) NSString *lastRolledBackHash;
+
+- (void)reset;
+- (NSDictionary *)toDictionary;
+- (NSString *)getActiveReleaseHash;
++ (instancetype)fromDictionary:(NSDictionary *)dict;
+
+@end

package/ios/main/StallionMeta.m

@@ -0,0 +1,98 @@
+//
+//  StallionMeta.m
+//  DoubleConversion
+//
+//  Created by Jasbir Singh Shergill on 28/01/25.
+//
+
+#import "StallionMeta.h"
+
+@implementation StallionMeta
+
+- (instancetype)init {
+    self = [super init];
+    if (self) [self reset];
+    return self;
+}
+
+- (void)reset {
+    self.switchState = SwitchStateProd;
+    self.currentProdSlot = SlotStateDefaultSlot;
+    self.currentStageSlot = SlotStateDefaultSlot;
+
+    self.stageTempHash = @"";
+    self.stageNewHash = @"";
+    self.prodTempHash = @"";
+    self.prodNewHash = @"";
+    self.prodStableHash = @"";
+    self.lastRolledBackHash = @"";
+}
+
+- (NSDictionary *)toDictionary {
+    @try {
+        return @{
+            @"switchState": [StallionMetaConstants stringFromSwitchState:self.switchState] ?: @"",
+            @"stageSlot": @{
+                    @"tempHash": self.stageTempHash ?: @"",
+                    @"newHash": self.stageNewHash ?: @"",
+                    @"currentSlot": [StallionMetaConstants stringFromSlotState:self.currentStageSlot] ?: @""
+            },
+            @"prodSlot": @{
+                    @"tempHash": self.prodTempHash ?: @"",
+                    @"newHash": self.prodNewHash ?: @"",
+                    @"stableHash": self.prodStableHash ?: @"",
+                    @"currentSlot": [StallionMetaConstants stringFromSlotState:self.currentProdSlot] ?: @""
+            },
+            @"lastRolledBackHash": self.lastRolledBackHash ?: @""
+        };
+    } @catch (NSException *exception) {
+        NSLog(@"Error in toDictionary: %@", exception.reason);
+        return @{};
+    }
+}
+
+- (NSString *)getActiveReleaseHash {
+    if (![self.prodTempHash isEqual:@""]) {
+        return self.prodTempHash;
+    }
+    switch (self.currentProdSlot) {
+        case SlotStateNewSlot:
+            return self.prodNewHash;
+        case SlotStateStableSlot:
+            return self.prodStableHash;
+        default:
+            return @"";
+    }
+}
+
++ (instancetype)fromDictionary:(NSDictionary *)dict {
+    @try {
+        if (!dict || ![dict isKindOfClass:[NSDictionary class]]) {
+            return [[StallionMeta alloc] init];
+        }
+
+        StallionMeta *meta = [[StallionMeta alloc] init];
+
+        meta.switchState = [StallionMetaConstants switchStateFromString:dict[@"switchState"] ?: @"prod"];
+        NSDictionary *stageSlot = dict[@"stageSlot"];
+        NSDictionary *prodSlot = dict[@"prodSlot"];
+
+        meta.stageTempHash = stageSlot[@"tempHash"] ?: @"";
+        meta.stageNewHash = stageSlot[@"newHash"] ?: @"";
+        meta.currentStageSlot = [StallionMetaConstants slotStateFromString:stageSlot[@"currentSlot"] ?: @"default_slot"];
+
+        meta.prodTempHash = prodSlot[@"tempHash"] ?: @"";
+        meta.prodNewHash = prodSlot[@"newHash"] ?: @"";
+        meta.prodStableHash = prodSlot[@"stableHash"] ?: @"";
+        meta.currentProdSlot = [StallionMetaConstants slotStateFromString:prodSlot[@"currentSlot"] ?: @"default_slot"];
+
+        meta.lastRolledBackHash = dict[@"lastRolledBackHash"] ?: @"";
+
+        return meta;
+    } @catch (NSException *exception) {
+        NSLog(@"Error in fromDictionary: %@", exception.reason);
+        return [[StallionMeta alloc] init];
+    }
+}
+
+@end

package/ios/main/StallionMetaConstants.h

@@ -0,0 +1,28 @@
+//
+//  StallionMetaConstants.h
+//  DoubleConversion
+//
+//  Created by Jasbir Singh Shergill on 28/01/25.
+//
+
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, SwitchState) {
+    SwitchStateProd,
+    SwitchStateStage
+};
+
+typedef NS_ENUM(NSInteger, SlotStates) {
+    SlotStateNewSlot,
+    SlotStateStableSlot,
+    SlotStateDefaultSlot
+};
+
+@interface StallionMetaConstants : NSObject
+
++ (SwitchState)switchStateFromString:(NSString *)value;
++ (SlotStates)slotStateFromString:(NSString *)value;
++ (NSString *)stringFromSwitchState:(SwitchState)state;
++ (NSString *)stringFromSlotState:(SlotStates)state;
+
+@end

package/ios/main/StallionMetaConstants.m

@@ -0,0 +1,42 @@
+//
+//  StallionMetaConstants.m
+//  DoubleConversion
+//
+//  Created by Jasbir Singh Shergill on 28/01/25.
+//
+
+#import "StallionMetaConstants.h"
+
+@implementation StallionMetaConstants
+
++ (SwitchState)switchStateFromString:(NSString *)value {
+    if ([value isEqualToString:@"PROD"]) return SwitchStateProd;
+    if ([value isEqualToString:@"STAGE"]) return SwitchStateStage;
+    @throw [NSException exceptionWithName:@"InvalidSwitchStateException" reason:@"Invalid SwitchState" userInfo:nil];
+}
+
++ (SlotStates)slotStateFromString:(NSString *)value {
+    if ([value isEqualToString:@"NEW_SLOT"]) return SlotStateNewSlot;
+    if ([value isEqualToString:@"STABLE_SLOT"]) return SlotStateStableSlot;
+    if ([value isEqualToString:@"DEFAULT_SLOT"]) return SlotStateDefaultSlot;
+    return SlotStateDefaultSlot;
+}
+
++ (NSString *)stringFromSwitchState:(SwitchState)state {
+    switch (state) {
+        case SwitchStateProd: return @"PROD";
+        case SwitchStateStage: return @"STAGE";
+        default: return @"unknown";
+    }
+}
+
++ (NSString *)stringFromSlotState:(SlotStates)state {
+    switch (state) {
+        case SlotStateNewSlot: return @"NEW_SLOT";
+        case SlotStateStableSlot: return @"STABLE_SLOT";
+        case SlotStateDefaultSlot: return @"DEFAULT_SLOT";
+        default: return @"unknown";
+    }
+}
+
+@end