@logbrew/react-native 0.1.10 → 0.1.11

package/ios/LBRNFatalStoreModule.mm

@@ -1,6 +1,11 @@
 #import "LBRNFatalStoreModule.h"
 
+#import "LBRNEventRecordStore.h"
 #import "LBRNFatalRecordStore.h"
+#import "LBRNPrivateStorage.h"
+
+#import <CommonCrypto/CommonDigest.h>
+#import <TargetConditionals.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <LogBrewReactNativeSpec/LogBrewReactNativeSpec.h>
@@ -11,6 +16,51 @@ static NSDictionary *LBRNStorageError(void)
     return @{ @"status" : @"storage_error" };
 }
 
+static BOOL LBRNPrepareProtectedDirectory(NSURL *directoryURL)
+{
+    NSError *writeError = nil;
+    if (![directoryURL setResourceValue:@YES
+                                 forKey:NSURLIsExcludedFromBackupKey
+                                  error:&writeError]
+        || writeError != nil) {
+        return NO;
+    }
+#if TARGET_OS_IPHONE
+    writeError = nil;
+    if (![directoryURL setResourceValue:NSFileProtectionCompleteUntilFirstUserAuthentication
+                                 forKey:NSURLFileProtectionKey
+                                  error:&writeError]
+        || writeError != nil) {
+        return NO;
+    }
+#endif
+    NSNumber *excluded = nil;
+    NSError *readError = nil;
+    return [directoryURL getResourceValue:&excluded
+                                   forKey:NSURLIsExcludedFromBackupKey
+                                    error:&readError]
+        && readError == nil && excluded.boolValue;
+}
+
+static NSString *LBRNQueueHash(NSString *queueKey)
+{
+    if (![queueKey isKindOfClass:[NSString class]]
+        || [queueKey stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]].length == 0) {
+        return nil;
+    }
+    NSData *data = [queueKey dataUsingEncoding:NSUTF8StringEncoding];
+    if (data.length == 0 || data.length > 4096) {
+        return nil;
+    }
+    unsigned char digest[CC_SHA256_DIGEST_LENGTH];
+    CC_SHA256(data.bytes, (CC_LONG)data.length, digest);
+    NSMutableString *value = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
+    for (NSUInteger index = 0; index < CC_SHA256_DIGEST_LENGTH; index += 1) {
+        [value appendFormat:@"%02x", digest[index]];
+    }
+    return value;
+}
+
 static NSDictionary *LBRNNormalizeRecord(NSDictionary *record)
 {
     if (![record isKindOfClass:[NSDictionary class]]) {
@@ -44,6 +94,8 @@ static NSDictionary *LBRNNormalizeRecord(NSDictionary *record)
 <NativeLogBrewFatalStoreSpec>
 #endif
 @property (nonatomic, nullable) LBRNFatalRecordStore *store;
+@property (nonatomic, nullable) NSURL *eventStoreParentURL;
+@property (nonatomic) NSMutableDictionary<NSString *, LBRNEventRecordStore *> *eventStores;
 @end
 
 @implementation LBRNFatalStoreModule
@@ -62,23 +114,13 @@ RCT_EXPORT_MODULE(LogBrewFatalStore)
         NSURL *baseURL =
             [[NSFileManager defaultManager] URLsForDirectory:NSApplicationSupportDirectory
                                                     inDomains:NSUserDomainMask].firstObject;
-        if (baseURL != nil) {
+        if (baseURL != nil && LBRNPreparePrivateRootDirectory(baseURL)) {
+            _eventStoreParentURL = baseURL;
+            _eventStores = [NSMutableDictionary dictionary];
             NSURL *directoryURL = [baseURL URLByAppendingPathComponent:@"LogBrewFatalJS"
                                                            isDirectory:YES];
             LBRNFatalDirectoryPreparation directoryPreparation = ^BOOL(NSURL *preparedURL) {
-              NSError *writeError = nil;
-              if (![preparedURL setResourceValue:@YES
-                                          forKey:NSURLIsExcludedFromBackupKey
-                                           error:&writeError]
-                  || writeError != nil) {
-                  return NO;
-              }
-              NSNumber *excluded = nil;
-              NSError *readError = nil;
-              return [preparedURL getResourceValue:&excluded
-                                            forKey:NSURLIsExcludedFromBackupKey
-                                             error:&readError]
-                  && readError == nil && excluded.boolValue;
+              return LBRNPrepareProtectedDirectory(preparedURL);
             };
             _store = [[LBRNFatalRecordStore alloc]
                 initWithDirectoryURL:directoryURL
@@ -88,6 +130,30 @@ RCT_EXPORT_MODULE(LogBrewFatalStore)
     return self;
 }
 
+- (nullable LBRNEventRecordStore *)eventStoreForQueueKey:(NSString *)queueKey
+{
+    NSString *queueHash = LBRNQueueHash(queueKey);
+    if (queueHash == nil || self.eventStoreParentURL == nil) {
+        return nil;
+    }
+    @synchronized(self) {
+        LBRNEventRecordStore *existing = self.eventStores[queueHash];
+        if (existing != nil) {
+            return existing;
+        }
+        NSURL *directoryURL = [self.eventStoreParentURL
+            URLByAppendingPathComponent:[@"LogBrewEventsV1-" stringByAppendingString:queueHash]
+                            isDirectory:YES];
+        LBRNEventRecordStore *created = [[LBRNEventRecordStore alloc]
+            initWithDirectoryURL:directoryURL
+            directoryPreparation:^BOOL(NSURL *preparedURL) {
+              return LBRNPrepareProtectedDirectory(preparedURL);
+            }];
+        self.eventStores[queueHash] = created;
+        return created;
+    }
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(writeFatalRecord:(NSDictionary *)record)
 {
     if (self.store == nil) {
@@ -136,6 +202,85 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(discardFatalRecord)
     }
 }
 
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(loadEventRecords:(NSString *)queueKey)
+{
+    LBRNEventRecordStore *eventStore = [self eventStoreForQueueKey:queueKey];
+    if (eventStore == nil) {
+        return LBRNStorageError();
+    }
+    @try {
+        return [eventStore loadRecords];
+    } @catch (__unused NSException *exception) {
+        return LBRNStorageError();
+    }
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(appendEventRecord:(NSString *)queueKey
+                                  serializedEvent:(NSString *)serializedEvent
+                                       eventBytes:(double)eventBytes)
+{
+    LBRNEventRecordStore *eventStore = [self eventStoreForQueueKey:queueKey];
+    if (eventStore == nil) {
+        return LBRNStorageError();
+    }
+    @try {
+        return [eventStore appendSerializedEvent:serializedEvent eventBytes:@(eventBytes)];
+    } @catch (__unused NSException *exception) {
+        return LBRNStorageError();
+    }
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(acknowledgeEventRecords:(NSString *)queueKey
+                                                      count:(double)count)
+{
+    LBRNEventRecordStore *eventStore = [self eventStoreForQueueKey:queueKey];
+    if (eventStore == nil) {
+        return LBRNStorageError();
+    }
+    @try {
+        return [eventStore acknowledgeRecordCount:@(count)];
+    } @catch (__unused NSException *exception) {
+        return LBRNStorageError();
+    }
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(purgeEventRecords:(NSString *)queueKey)
+{
+    LBRNEventRecordStore *eventStore = [self eventStoreForQueueKey:queueKey];
+    if (eventStore == nil) {
+        return LBRNStorageError();
+    }
+    @try {
+        return [eventStore purgeRecords];
+    } @catch (__unused NSException *exception) {
+        return LBRNStorageError();
+    }
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(closeEventStore:(NSString *)queueKey)
+{
+    NSString *queueHash = LBRNQueueHash(queueKey);
+    if (queueHash == nil) {
+        return LBRNStorageError();
+    }
+    LBRNEventRecordStore *eventStore = nil;
+    @synchronized(self) {
+        eventStore = self.eventStores[queueHash];
+    }
+    if (eventStore == nil) {
+        return @{ @"status" : @"closed" };
+    }
+    @try {
+        return [eventStore closeStore];
+    } @catch (__unused NSException *exception) {
+        return LBRNStorageError();
+    } @finally {
+        @synchronized(self) {
+            [self.eventStores removeObjectForKey:queueHash];
+        }
+    }
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params

package/ios/LBRNPrivateStorage.h

@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+FOUNDATION_EXPORT BOOL LBRNPreparePrivateRootDirectory(NSURL *directoryURL);
+
+NS_ASSUME_NONNULL_END

package/ios/LBRNPrivateStorage.m

@@ -0,0 +1,38 @@
+#import "LBRNPrivateStorage.h"
+
+#import <errno.h>
+#import <fcntl.h>
+#import <sys/stat.h>
+#import <unistd.h>
+
+BOOL LBRNPreparePrivateRootDirectory(NSURL *directoryURL)
+{
+    if (!directoryURL.isFileURL) {
+        return NO;
+    }
+    const char *path = directoryURL.fileSystemRepresentation;
+    struct stat pathInfo;
+    if (lstat(path, &pathInfo) != 0) {
+        if (errno != ENOENT || mkdir(path, 0700) != 0) {
+            return NO;
+        }
+    } else if (!S_ISDIR(pathInfo.st_mode) || S_ISLNK(pathInfo.st_mode)) {
+        return NO;
+    }
+
+    int directoryFD = open(path, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
+    if (directoryFD < 0) {
+        return NO;
+    }
+    struct stat openedInfo;
+    BOOL prepared = fstat(directoryFD, &openedInfo) == 0
+        && S_ISDIR(openedInfo.st_mode)
+        && fchmod(directoryFD, 0700) == 0
+        && lstat(path, &pathInfo) == 0
+        && S_ISDIR(pathInfo.st_mode)
+        && !S_ISLNK(pathInfo.st_mode)
+        && openedInfo.st_dev == pathInfo.st_dev
+        && openedInfo.st_ino == pathInfo.st_ino;
+    close(directoryFD);
+    return prepared;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@logbrew/react-native",
-  "version": "0.1.10",
-  "description": "React Native screen, error, trace, action, and network timeline helpers for LogBrew.",
+  "version": "0.1.11",
+  "description": "React Native offline delivery, screen, error, trace, action, and network timeline helpers for LogBrew.",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
@@ -138,6 +138,7 @@
     "global-errors.cjs",
     "promise-rejections.cjs",
     "fatal-replay.cjs",
+    "persistent-delivery.native.js",
     "global-errors.js",
     "global-errors.native.js",
     "global-errors.d.ts",
@@ -169,6 +170,10 @@
     "ios/LBRNFatalRecordStore.m",
     "ios/LBRNFatalStoreModule.h",
     "ios/LBRNFatalStoreModule.mm",
+    "ios/LBRNPrivateStorage.h",
+    "ios/LBRNPrivateStorage.m",
+    "ios/LBRNEventRecordStore.h",
+    "ios/LBRNEventRecordStore.m",
     "react-native.config.js",
     "src",
     "README.md",

package/persistent-delivery.native.js

@@ -0,0 +1,282 @@
+import { SdkError } from "@logbrew/sdk";
+import { NativeModules, TurboModuleRegistry } from "react-native";
+
+const ACTIVE_QUEUE_KEYS = new Set();
+const MAX_NATIVE_QUEUE_BYTES = 4 * 1024 * 1024;
+const MAX_NATIVE_QUEUE_EVENTS = 1000;
+const NATIVE_STORE_METHODS = [
+  "acknowledgeEventRecords",
+  "appendEventRecord",
+  "closeEventStore",
+  "loadEventRecords",
+  "purgeEventRecords"
+];
+const PERSISTENT_QUEUE_MODES = new Set(["auto", "disabled", "required"]);
+
+export function resolveReactNativePersistentEventStore({
+  authKey,
+  eventStore,
+  hasExplicitPersistentQueue = false,
+  maxQueueBytes,
+  maxQueueSize,
+  persistentQueue = "auto"
+}) {
+  validatePersistentQueueMode(persistentQueue);
+  if (eventStore !== undefined) {
+    if (hasExplicitPersistentQueue) {
+      throw new SdkError(
+        "configuration_error",
+        "eventStore and persistentQueue are mutually exclusive"
+      );
+    }
+    return { eventStore, abort() {}, release() {} };
+  }
+  if (persistentQueue === "disabled") {
+    return { eventStore: undefined, abort() {}, release() {} };
+  }
+
+  const nativeStore = defaultNativeStore();
+  if (!nativeStore) {
+    if (persistentQueue === "required") {
+      throw new SdkError(
+        "configuration_error",
+        "React Native persistent queue requires the linked LogBrew native module"
+      );
+    }
+    return { eventStore: undefined, abort() {}, release() {} };
+  }
+  validateNativeQueueLimits({ maxQueueBytes, maxQueueSize });
+  if (ACTIVE_QUEUE_KEYS.has(authKey)) {
+    throw new SdkError(
+      "configuration_error",
+      "React Native persistent queue already has an active client for this key"
+    );
+  }
+
+  ACTIVE_QUEUE_KEYS.add(authKey);
+  let released = false;
+  const release = () => {
+    if (!released) {
+      released = true;
+      ACTIVE_QUEUE_KEYS.delete(authKey);
+    }
+  };
+  const nativeEventStore = createNativeEventStore(nativeStore, authKey, release);
+  return {
+    eventStore: nativeEventStore,
+    abort() {
+      try {
+        nativeEventStore.close();
+      } catch {
+        release();
+      }
+    },
+    release
+  };
+}
+
+export function purgeReactNativePersistentQueue({ apiKey, clientKey } = {}) {
+  const authKey = clientKey ?? apiKey;
+  if (typeof authKey !== "string" || authKey.trim() === "") {
+    throw new SdkError(
+      "configuration_error",
+      "purgeLogBrewReactNativePersistentQueue requires clientKey or apiKey"
+    );
+  }
+  if (ACTIVE_QUEUE_KEYS.has(authKey)) {
+    throw new SdkError(
+      "persistence_error",
+      "cannot purge a React Native persistent queue while its client is active"
+    );
+  }
+  const nativeStore = defaultNativeStore();
+  if (!nativeStore) {
+    throw new SdkError(
+      "configuration_error",
+      "React Native persistent queue requires the linked LogBrew native module"
+    );
+  }
+  let failure;
+  try {
+    requireStatus(
+      "purge",
+      callNative(nativeStore, "purgeEventRecords", authKey),
+      "purged"
+    );
+  } catch (error) {
+    failure = error;
+  }
+  try {
+    requireStatus(
+      "close",
+      callNative(nativeStore, "closeEventStore", authKey),
+      "closed"
+    );
+  } catch (error) {
+    failure ??= error;
+  }
+  if (failure) {
+    throw failure;
+  }
+}
+
+function createNativeEventStore(nativeStore, authKey, release) {
+  return {
+    load() {
+      const result = requireStatus(
+        "load",
+        callNative(nativeStore, "loadEventRecords", authKey),
+        "loaded"
+      );
+      if (!Array.isArray(result.records)) {
+        throw persistenceFailure("load");
+      }
+      return result.records.map((record) => {
+        if (!record
+          || Array.isArray(record)
+          || typeof record !== "object"
+          || typeof record.serializedEvent !== "string"
+          || !Number.isSafeInteger(record.eventBytes)
+          || record.eventBytes <= 0) {
+          throw persistenceFailure("load");
+        }
+        let event;
+        try {
+          event = JSON.parse(record.serializedEvent);
+        } catch {
+          throw persistenceFailure("load");
+        }
+        return {
+          event,
+          eventBytes: record.eventBytes,
+          serializedEvent: record.serializedEvent
+        };
+      });
+    },
+    append(record) {
+      requireStatus(
+        "append",
+        callNative(
+          nativeStore,
+          "appendEventRecord",
+          authKey,
+          record.serializedEvent,
+          record.eventBytes
+        ),
+        "appended"
+      );
+    },
+    acknowledge(count) {
+      requireStatus(
+        "acknowledge",
+        callNative(nativeStore, "acknowledgeEventRecords", authKey, count),
+        "acknowledged"
+      );
+    },
+    purge() {
+      requireStatus(
+        "purge",
+        callNative(nativeStore, "purgeEventRecords", authKey),
+        "purged"
+      );
+    },
+    close() {
+      try {
+        requireStatus(
+          "close",
+          callNative(nativeStore, "closeEventStore", authKey),
+          "closed"
+        );
+      } finally {
+        release();
+      }
+    }
+  };
+}
+
+function defaultNativeStore() {
+  try {
+    const nativeStore = TurboModuleRegistry?.get?.("LogBrewFatalStore")
+      ?? NativeModules?.LogBrewFatalStore;
+    return NATIVE_STORE_METHODS.every((method) => typeof nativeStore?.[method] === "function")
+      ? nativeStore
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function validateNativeQueueLimits({ maxQueueBytes, maxQueueSize }) {
+  if (maxQueueBytes !== undefined
+    && (!Number.isSafeInteger(maxQueueBytes)
+      || maxQueueBytes <= 0
+      || maxQueueBytes > MAX_NATIVE_QUEUE_BYTES)) {
+    throw new SdkError(
+      "configuration_error",
+      `persistent React Native maxQueueBytes must be at most ${MAX_NATIVE_QUEUE_BYTES}`
+    );
+  }
+  if (maxQueueSize !== undefined
+    && (!Number.isSafeInteger(maxQueueSize)
+      || maxQueueSize <= 0
+      || maxQueueSize > MAX_NATIVE_QUEUE_EVENTS)) {
+    throw new SdkError(
+      "configuration_error",
+      `persistent React Native maxQueueSize must be at most ${MAX_NATIVE_QUEUE_EVENTS}`
+    );
+  }
+}
+
+function validatePersistentQueueMode(mode) {
+  if (!PERSISTENT_QUEUE_MODES.has(mode)) {
+    throw new SdkError(
+      "configuration_error",
+      "persistentQueue must be auto, required, or disabled"
+    );
+  }
+}
+
+function callNative(nativeStore, method, ...args) {
+  if (typeof nativeStore?.[method] !== "function") {
+    throw persistenceFailure(methodName(method));
+  }
+  try {
+    return nativeStore[method](...args);
+  } catch {
+    throw persistenceFailure(methodName(method));
+  }
+}
+
+function requireStatus(operation, result, expected) {
+  if (!result
+    || Array.isArray(result)
+    || typeof result !== "object"
+    || result.status !== expected) {
+    throw persistenceFailure(operation);
+  }
+  return result;
+}
+
+function methodName(method) {
+  switch (method) {
+    case "loadEventRecords":
+      return "load";
+    case "appendEventRecord":
+      return "append";
+    case "acknowledgeEventRecords":
+      return "acknowledge";
+    case "purgeEventRecords":
+      return "purge";
+    case "closeEventStore":
+      return "close";
+    default:
+      return "operation";
+  }
+}
+
+function persistenceFailure(operation) {
+  return new SdkError(
+    "persistence_error",
+    `React Native persistent queue ${operation} failed`
+  );
+}

package/src/NativeLogBrewFatalStore.ts

@@ -6,6 +6,15 @@ export interface Spec extends TurboModule {
   readFatalRecord(): CodegenTypes.UnsafeObject;
   acknowledgeFatalRecord(recordId: string): CodegenTypes.UnsafeObject;
   discardFatalRecord(): CodegenTypes.UnsafeObject;
+  loadEventRecords(queueKey: string): CodegenTypes.UnsafeObject;
+  appendEventRecord(
+    queueKey: string,
+    serializedEvent: string,
+    eventBytes: number
+  ): CodegenTypes.UnsafeObject;
+  acknowledgeEventRecords(queueKey: string, count: number): CodegenTypes.UnsafeObject;
+  purgeEventRecords(queueKey: string): CodegenTypes.UnsafeObject;
+  closeEventStore(queueKey: string): CodegenTypes.UnsafeObject;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>("LogBrewFatalStore");