@rejourneyco/react-native 1.0.0

package/ios/Utils/RJEventBuffer.h

@@ -0,0 +1,112 @@
+//
+//  RJEventBuffer.h
+//  Rejourney
+//
+//  Write-first event buffer that persists events to disk immediately.
+//  Industry-standard approach: events are never lost even on force-kill.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Write-first event buffer for crash-safe event persistence.
+ *
+ * Events are written to disk immediately when logged, ensuring no data loss
+ * even if the app is force-killed. Events are read back for upload on next
+ * app launch if not uploaded during the session.
+ *
+ * File format: JSONL (one JSON object per line) for efficient append
+ * operations.
+ */
+@interface RJEventBuffer : NSObject
+
+/// Session ID this buffer is associated with
+@property(nonatomic, copy, readonly) NSString *sessionId;
+
+/// Base directory for pending session data
+@property(nonatomic, copy, readonly) NSString *pendingRootPath;
+
+/// Number of events currently buffered on disk
+@property(nonatomic, readonly) NSInteger eventCount;
+
+/// Timestamp of the last event written (milliseconds since epoch)
+@property(nonatomic, readonly) NSTimeInterval lastEventTimestamp;
+
+#pragma mark - Initialization
+
+/**
+ * Creates an event buffer for the specified session.
+ *
+ * @param sessionId The session ID to buffer events for.
+ * @param pendingRootPath Base directory for pending session data.
+ * @return A new event buffer instance.
+ */
+- (instancetype)initWithSessionId:(NSString *)sessionId
+                  pendingRootPath:(NSString *)pendingRootPath;
+
+/// Unavailable. Use initWithSessionId:pendingRootPath: instead.
+- (instancetype)init NS_UNAVAILABLE;
+
+#pragma mark - Event Operations
+
+/**
+ * Appends an event to the buffer, writing immediately to disk.
+ * This operation is synchronous and thread-safe.
+ *
+ * @param event The event dictionary to persist.
+ * @return YES if the event was successfully written, NO otherwise.
+ */
+- (BOOL)appendEvent:(NSDictionary *)event;
+
+/**
+ * Appends multiple events to the buffer atomically.
+ *
+ * @param events Array of event dictionaries to persist.
+ * @return YES if all events were successfully written, NO otherwise.
+ */
+- (BOOL)appendEvents:(NSArray<NSDictionary *> *)events;
+
+/**
+ * Reads all buffered events from disk.
+ * Used for upload or recovery.
+ *
+ * @return Array of event dictionaries, or empty array if no events.
+ */
+- (NSArray<NSDictionary *> *)readAllEvents;
+
+/**
+ * Reads events that haven't been uploaded yet (after the given batch number).
+ *
+ * @param afterBatchNumber Only return events logged after this batch was
+ * uploaded.
+ * @return Array of event dictionaries.
+ */
+- (NSArray<NSDictionary *> *)readEventsAfterBatchNumber:
+    (NSInteger)afterBatchNumber;
+
+/**
+ * Marks events up to the given index as uploaded.
+ * This allows incremental uploads without losing state.
+ *
+ * @param eventIndex The index of the last successfully uploaded event.
+ */
+- (void)markEventsUploadedUpToIndex:(NSInteger)eventIndex;
+
+/**
+ * Clears all buffered events from disk.
+ * Call after session is successfully closed.
+ */
+- (void)clearAllEvents;
+
+/**
+ * Returns the timestamp of the last event, useful for session end time.
+ */
+- (NSTimeInterval)lastEventTimestampMs;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Utils/RJEventBuffer.m

@@ -0,0 +1,358 @@
+//
+//  RJEventBuffer.m
+//  Rejourney
+//
+//  Write-first event buffer implementation.
+//  Events are persisted to disk immediately in JSONL format.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import "RJEventBuffer.h"
+#import "../Core/RJLogger.h"
+
+static void *kRJEventBufferQueueKey = &kRJEventBufferQueueKey;
+
+@interface RJEventBuffer ()
+
+@property(nonatomic, copy, readwrite) NSString *sessionId;
+@property(nonatomic, copy, readwrite) NSString *pendingRootPath;
+@property(nonatomic, strong) NSFileHandle *fileHandle;
+@property(nonatomic, copy) NSString *eventsFilePath;
+@property(nonatomic, assign, readwrite) NSInteger eventCount;
+@property(nonatomic, assign, readwrite) NSTimeInterval lastEventTimestamp;
+@property(nonatomic, strong) dispatch_queue_t writeQueue;
+@property(nonatomic, assign) NSInteger uploadedEventCount;
+
+@end
+
+@implementation RJEventBuffer
+
+#pragma mark - Initialization
+
+- (instancetype)initWithSessionId:(NSString *)sessionId
+                  pendingRootPath:(NSString *)pendingRootPath {
+  self = [super init];
+  if (self) {
+    _sessionId = [sessionId copy];
+    if (pendingRootPath.length == 0) {
+      NSString *defaultPath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
+                                                                    NSUserDomainMask, YES)
+                               .firstObject stringByAppendingPathComponent:@"rj_pending"];
+      _pendingRootPath = [defaultPath copy];
+    } else {
+      _pendingRootPath = [pendingRootPath copy];
+    }
+    _eventCount = 0;
+    _lastEventTimestamp = 0;
+    _uploadedEventCount = 0;
+    _writeQueue = dispatch_queue_create("com.rejourney.eventbuffer",
+                                        DISPATCH_QUEUE_SERIAL);
+    dispatch_queue_set_specific(_writeQueue, kRJEventBufferQueueKey,
+                                kRJEventBufferQueueKey, NULL);
+
+    [self setupEventsFile];
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [self performWriteSync:^{
+    [self closeFileHandle];
+  }];
+}
+
+#pragma mark - File Setup
+
+- (void)setupEventsFile {
+  NSString *sessionDir =
+      [self.pendingRootPath stringByAppendingPathComponent:self.sessionId];
+
+  
+  NSFileManager *fm = [NSFileManager defaultManager];
+  if (![fm fileExistsAtPath:sessionDir]) {
+    NSError *error = nil;
+    [fm createDirectoryAtPath:sessionDir
+        withIntermediateDirectories:YES
+                         attributes:nil
+                              error:&error];
+    if (error) {
+      RJLogError(@"Failed to create session directory: %@", error);
+      return;
+    }
+  }
+
+  self.eventsFilePath =
+      [sessionDir stringByAppendingPathComponent:@"events.jsonl"];
+
+  if (![fm fileExistsAtPath:self.eventsFilePath]) {
+    NSDictionary *attrs = @{
+      NSFileProtectionKey: NSFileProtectionCompleteUntilFirstUserAuthentication
+    };
+    [fm createFileAtPath:self.eventsFilePath contents:nil attributes:attrs];
+  }
+
+  
+  NSError *error = nil;
+  self.fileHandle =
+      [NSFileHandle fileHandleForWritingAtPath:self.eventsFilePath];
+  if (!self.fileHandle) {
+    RJLogError(@"Failed to open events file for writing: %@",
+               self.eventsFilePath);
+    return;
+  }
+
+  
+  if (@available(iOS 13.0, *)) {
+    [self.fileHandle seekToEndReturningOffset:nil error:&error];
+  } else {
+    [self.fileHandle seekToEndOfFile];
+  }
+
+  
+  [self countExistingEvents];
+
+  RJLogDebug(@"Event buffer ready: %@ (%ld existing events)",
+             self.eventsFilePath, (long)self.eventCount);
+}
+
+- (void)countExistingEvents {
+  NSError *error = nil;
+  NSString *content = [NSString stringWithContentsOfFile:self.eventsFilePath
+                                                encoding:NSUTF8StringEncoding
+                                                   error:&error];
+  if (error || !content) {
+    self.eventCount = 0;
+    return;
+  }
+
+  NSArray<NSString *> *lines = [content componentsSeparatedByString:@"\n"];
+  NSInteger count = 0;
+  NSTimeInterval lastTs = 0;
+
+  for (NSString *line in lines) {
+    if (line.length == 0)
+      continue;
+
+    NSData *data = [line dataUsingEncoding:NSUTF8StringEncoding];
+    NSDictionary *event = [NSJSONSerialization JSONObjectWithData:data
+                                                          options:0
+                                                            error:nil];
+    if (event) {
+      count++;
+      NSNumber *ts = event[@"timestamp"];
+      if (ts && [ts doubleValue] > lastTs) {
+        lastTs = [ts doubleValue];
+      }
+    }
+  }
+
+  self.eventCount = count;
+  self.lastEventTimestamp = lastTs;
+}
+
+- (void)closeFileHandle {
+  if (self.fileHandle) {
+    if (@available(iOS 13.0, *)) {
+      [self.fileHandle closeAndReturnError:nil];
+    } else {
+      [self.fileHandle closeFile];
+    }
+    self.fileHandle = nil;
+  }
+}
+
+#pragma mark - Event Operations
+
+- (void)performWriteSync:(dispatch_block_t)block {
+  if (!block || !self.writeQueue) {
+    return;
+  }
+
+  if (dispatch_get_specific(kRJEventBufferQueueKey)) {
+    block();
+  } else {
+    dispatch_sync(self.writeQueue, block);
+  }
+}
+
+- (BOOL)appendEvent:(NSDictionary *)event {
+  if (!event)
+    return NO;
+
+  __block BOOL success = NO;
+
+  [self performWriteSync:^{
+    success = [self writeEventToDisk:event];
+  }];
+
+  return success;
+}
+
+- (BOOL)appendEvents:(NSArray<NSDictionary *> *)events {
+  if (!events || events.count == 0)
+    return YES;
+
+  __block BOOL success = YES;
+
+  [self performWriteSync:^{
+    for (NSDictionary *event in events) {
+      if (![self writeEventToDisk:event]) {
+        success = NO;
+      }
+    }
+  }];
+
+  return success;
+}
+
+- (BOOL)writeEventToDisk:(NSDictionary *)event {
+  if (!self.fileHandle) {
+    RJLogWarning(@"Event buffer file handle not available");
+    return NO;
+  }
+
+  @try {
+    NSError *jsonError = nil;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:event
+                                                       options:0
+                                                         error:&jsonError];
+    if (jsonError || !jsonData) {
+      RJLogWarning(@"Failed to serialize event: %@", jsonError);
+      return NO;
+    }
+
+    
+    NSMutableData *lineData = [jsonData mutableCopy];
+    [lineData appendData:[@"\n" dataUsingEncoding:NSUTF8StringEncoding]];
+
+    
+    if (@available(iOS 13.4, *)) {
+      NSError *writeError = nil;
+      [self.fileHandle writeData:lineData error:&writeError];
+      if (writeError) {
+        RJLogWarning(@"Failed to write event: %@", writeError);
+        return NO;
+      }
+    } else {
+      @try {
+        [self.fileHandle writeData:lineData];
+      } @catch (NSException *e) {
+        RJLogWarning(@"Failed to write event: %@", e);
+        return NO;
+      }
+    }
+
+    
+    if (@available(iOS 13.0, *)) {
+      [self.fileHandle synchronizeAndReturnError:nil];
+    } else {
+      [self.fileHandle synchronizeFile];
+    }
+
+    
+    self.eventCount++;
+    NSNumber *ts = event[@"timestamp"];
+    if (ts) {
+      self.lastEventTimestamp = [ts doubleValue];
+    }
+
+    return YES;
+
+  } @catch (NSException *exception) {
+    RJLogError(@"Exception writing event: %@", exception);
+    return NO;
+  }
+}
+
+- (NSArray<NSDictionary *> *)readAllEvents {
+  __block NSMutableArray<NSDictionary *> *events = [NSMutableArray new];
+
+  [self performWriteSync:^{
+    NSError *error = nil;
+    NSString *content = [NSString stringWithContentsOfFile:self.eventsFilePath
+                                                  encoding:NSUTF8StringEncoding
+                                                     error:&error];
+    if (error || !content) {
+      return;
+    }
+
+    NSArray<NSString *> *lines = [content componentsSeparatedByString:@"\n"];
+    for (NSString *line in lines) {
+      if (line.length == 0)
+        continue;
+
+      NSData *data = [line dataUsingEncoding:NSUTF8StringEncoding];
+      NSDictionary *event = [NSJSONSerialization JSONObjectWithData:data
+                                                            options:0
+                                                              error:nil];
+      if (event) {
+        [events addObject:event];
+      }
+    }
+  }];
+
+  return events;
+}
+
+- (NSArray<NSDictionary *> *)readEventsAfterBatchNumber:
+    (NSInteger)afterBatchNumber {
+  
+  NSArray<NSDictionary *> *allEvents = [self readAllEvents];
+
+  __block NSInteger uploadedCount = 0;
+  [self performWriteSync:^{
+    uploadedCount = self.uploadedEventCount;
+  }];
+
+  NSInteger startIndex = MAX(uploadedCount, MAX(0, afterBatchNumber));
+  if (startIndex >= allEvents.count) {
+    return @[];
+  }
+
+  return [allEvents subarrayWithRange:NSMakeRange(
+                                           startIndex,
+                                           allEvents.count - startIndex)];
+}
+
+- (void)markEventsUploadedUpToIndex:(NSInteger)eventIndex {
+  [self performWriteSync:^{
+    self.uploadedEventCount = eventIndex;
+
+    NSString *metaPath =
+        [[self.eventsFilePath stringByDeletingLastPathComponent]
+            stringByAppendingPathComponent:@"buffer_meta.json"];
+    NSDictionary *meta = @{
+      @"uploadedEventCount" : @(self.uploadedEventCount),
+      @"lastEventTimestamp" : @(self.lastEventTimestamp)
+    };
+    NSData *data = [NSJSONSerialization dataWithJSONObject:meta
+                                                   options:0
+                                                     error:nil];
+    [data writeToFile:metaPath atomically:YES];
+  }];
+}
+
+- (void)clearAllEvents {
+  [self performWriteSync:^{
+    [self closeFileHandle];
+
+    NSFileManager *fm = [NSFileManager defaultManager];
+    [fm removeItemAtPath:self.eventsFilePath error:nil];
+
+    NSString *metaPath =
+        [[self.eventsFilePath stringByDeletingLastPathComponent]
+            stringByAppendingPathComponent:@"buffer_meta.json"];
+    [fm removeItemAtPath:metaPath error:nil];
+
+    self.eventCount = 0;
+    self.uploadedEventCount = 0;
+    self.lastEventTimestamp = 0;
+  }];
+}
+
+- (NSTimeInterval)lastEventTimestampMs {
+  return self.lastEventTimestamp;
+}
+
+@end

package/ios/Utils/RJGzipUtils.h

@@ -0,0 +1,33 @@
+//
+//  RJGzipUtils.h
+//  Rejourney
+//
+//  Gzip compression and Base64 decoding utilities.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Gzip compress data using zlib (with gzip headers).
+ *
+ * @param input The data to compress.
+ * @param error Optional pointer to receive error information.
+ * @return The compressed data, or nil on failure.
+ */
+NSData *_Nullable RJGzipData(NSData *input, NSError **error);
+
+/**
+ * Decode base64 data from a data URI or plain base64 string.
+ * Handles data URIs (removes "data:...;base64," prefix) and
+ * delta prefixes ("delta:...").
+ *
+ * @param dataString The base64 string to decode.
+ * @return The decoded data, or nil on failure.
+ */
+NSData *_Nullable RJDecodeBase64Data(NSString *dataString);
+
+NS_ASSUME_NONNULL_END

package/ios/Utils/RJGzipUtils.m

@@ -0,0 +1,89 @@
+//
+//  RJGzipUtils.m
+//  Rejourney
+//
+//  Gzip compression and Base64 decoding utilities implementation.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import "RJGzipUtils.h"
+#import <zlib.h>
+
+NSData *_Nullable RJGzipData(NSData *input, NSError **error) {
+  if (!input || input.length == 0)
+    return input;
+
+  z_stream stream;
+  stream.zalloc = Z_NULL;
+  stream.zfree = Z_NULL;
+  stream.opaque = Z_NULL;
+  stream.next_in = (Bytef *)input.bytes;
+  stream.avail_in = (uInt)input.length;
+
+  
+  if (deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8,
+                   Z_DEFAULT_STRATEGY) != Z_OK) {
+    if (error) {
+      *error =
+          [NSError errorWithDomain:@"com.rejourney.gzip"
+                              code:-1
+                          userInfo:@{
+                            NSLocalizedDescriptionKey : @"Failed to init gzip"
+                          }];
+    }
+    return nil;
+  }
+
+  NSMutableData *compressed =
+      [NSMutableData dataWithLength:input.length * 1.1 + 32];
+
+  int status;
+  do {
+    if (stream.total_out >= compressed.length) {
+      [compressed increaseLengthBy:input.length / 2];
+    }
+
+    stream.next_out = (Bytef *)compressed.mutableBytes + stream.total_out;
+    stream.avail_out = (uInt)(compressed.length - stream.total_out);
+
+    status = deflate(&stream, Z_FINISH);
+  } while (status == Z_OK);
+
+  if (status != Z_STREAM_END) {
+    deflateEnd(&stream);
+    if (error) {
+      *error =
+          [NSError errorWithDomain:@"com.rejourney.gzip"
+                              code:status
+                          userInfo:@{
+                            NSLocalizedDescriptionKey : @"Failed to gzip data"
+                          }];
+    }
+    return nil;
+  }
+
+  deflateEnd(&stream);
+  [compressed setLength:stream.total_out];
+  return compressed;
+}
+
+NSData *_Nullable RJDecodeBase64Data(NSString *dataString) {
+  if (!dataString || dataString.length == 0)
+    return nil;
+
+  NSString *clean = dataString;
+  NSRange comma = [dataString rangeOfString:@","];
+  if (comma.location != NSNotFound) {
+    clean = [dataString substringFromIndex:comma.location + 1];
+  }
+
+  
+  if ([clean hasPrefix:@"delta:"]) {
+    clean = [clean substringFromIndex:6]; 
+  }
+
+  return [[NSData alloc]
+      initWithBase64EncodedString:clean
+                          options:NSDataBase64DecodingIgnoreUnknownCharacters];
+}

package/ios/Utils/RJKeychainManager.h

@@ -0,0 +1,48 @@
+//
+//  RJKeychainManager.h
+//  Rejourney
+//
+//  Secure Keychain storage for sensitive credentials.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Manages secure storage of sensitive data in iOS Keychain.
+ */
+@interface RJKeychainManager : NSObject
+
+/// Shared instance
++ (instancetype)sharedManager;
+
+/// Store a string value securely
+- (BOOL)setString:(NSString *)value forKey:(NSString *)key;
+
+/// Retrieve a string value
+- (nullable NSString *)stringForKey:(NSString *)key;
+
+/// Delete a value
+- (BOOL)deleteValueForKey:(NSString *)key;
+
+/// Clear all Rejourney keychain items
+- (void)clearAll;
+
+@end
+
+NS_ASSUME_NONNULL_END