react-native-nitro-storage 0.3.0 → 0.3.2

package/lib/module/index.js

@@ -1,11 +1,19 @@
 "use strict";
 
-import { useRef, useSyncExternalStore } from "react";
 import { NitroModules } from "react-native-nitro-modules";
-import { StorageScope } from "./Storage.types";
-import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, decodeNativeBatchValue, serializeWithPrimitiveFastPath, deserializeWithPrimitiveFastPath } from "./internal";
-export { StorageScope } from "./Storage.types";
+import { StorageScope, AccessControl } from "./Storage.types";
+import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, decodeNativeBatchValue, serializeWithPrimitiveFastPath, deserializeWithPrimitiveFastPath, prefixKey, isNamespaced } from "./internal";
+export { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
 export { migrateFromMMKV } from "./migration";
+function asInternal(item) {
+  return item;
+}
+function isUpdater(valueOrFn) {
+  return typeof valueOrFn === "function";
+}
+function typedKeys(record) {
+  return Object.keys(record);
+}
 const registeredMigrations = new Map();
 const runMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : task => {
   Promise.resolve().then(task);
@@ -24,6 +32,7 @@ const scopedUnsubscribers = new Map();
 const scopedRawCache = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
 const pendingSecureWrites = new Map();
 let secureFlushScheduled = false;
+let secureDefaultAccessControl = AccessControl.WhenUnlocked;
 function getScopedListeners(scope) {
   return scopedListeners.get(scope);
 }
@@ -99,6 +108,7 @@ function flushSecureWrites() {
     }
   });
   const storageModule = getStorageModule();
+  storageModule.setSecureAccessControl(secureDefaultAccessControl);
   if (keysToSet.length > 0) {
     storageModule.setBatch(keysToSet, valuesToSet, StorageScope.Secure);
   }
@@ -172,6 +182,7 @@ function setRawValue(key, value, scope) {
   if (scope === StorageScope.Secure) {
     flushSecureWrites();
     clearPendingSecureWrite(key);
+    getStorageModule().setSecureAccessControl(secureDefaultAccessControl);
   }
   getStorageModule().set(key, value, scope);
   cacheRawValue(scope, key, value);
@@ -219,10 +230,86 @@ export const storage = {
     storage.clear(StorageScope.Memory);
     storage.clear(StorageScope.Disk);
     storage.clear(StorageScope.Secure);
+  },
+  clearNamespace: (namespace, scope) => {
+    assertValidScope(scope);
+    if (scope === StorageScope.Memory) {
+      for (const key of memoryStore.keys()) {
+        if (isNamespaced(key, namespace)) {
+          memoryStore.delete(key);
+        }
+      }
+      notifyAllListeners(memoryListeners);
+      return;
+    }
+    const keyPrefix = prefixKey(namespace, "");
+    if (scope === StorageScope.Secure) {
+      flushSecureWrites();
+    }
+    clearScopeRawCache(scope);
+    getStorageModule().removeByPrefix(keyPrefix, scope);
+  },
+  clearBiometric: () => {
+    getStorageModule().clearSecureBiometric();
+  },
+  has: (key, scope) => {
+    assertValidScope(scope);
+    if (scope === StorageScope.Memory) {
+      return memoryStore.has(key);
+    }
+    return getStorageModule().has(key, scope);
+  },
+  getAllKeys: scope => {
+    assertValidScope(scope);
+    if (scope === StorageScope.Memory) {
+      return Array.from(memoryStore.keys());
+    }
+    return getStorageModule().getAllKeys(scope);
+  },
+  getAll: scope => {
+    assertValidScope(scope);
+    const result = {};
+    if (scope === StorageScope.Memory) {
+      memoryStore.forEach((value, key) => {
+        if (typeof value === "string") result[key] = value;
+      });
+      return result;
+    }
+    const keys = getStorageModule().getAllKeys(scope);
+    if (keys.length === 0) return result;
+    const values = getStorageModule().getBatch(keys, scope);
+    keys.forEach((key, idx) => {
+      const val = decodeNativeBatchValue(values[idx]);
+      if (val !== undefined) result[key] = val;
+    });
+    return result;
+  },
+  size: scope => {
+    assertValidScope(scope);
+    if (scope === StorageScope.Memory) {
+      return memoryStore.size;
+    }
+    return getStorageModule().size(scope);
+  },
+  setAccessControl: level => {
+    secureDefaultAccessControl = level;
+    getStorageModule().setSecureAccessControl(level);
+  },
+  setSecureWritesAsync: enabled => {
+    getStorageModule().setSecureWritesAsync(enabled);
+  },
+  flushSecureWrites: () => {
+    flushSecureWrites();
+  },
+  setKeychainAccessGroup: group => {
+    getStorageModule().setKeychainAccessGroup(group);
   }
 };
 function canUseRawBatchPath(item) {
-  return item._hasExpiration === false && item._hasValidation === false;
+  return item._hasExpiration === false && item._hasValidation === false && item._isBiometric !== true && item._secureAccessControl === undefined;
+}
+function canUseSecureRawBatchPath(item) {
+  return item._hasExpiration === false && item._hasValidation === false && item._isBiometric !== true;
 }
 function defaultSerialize(value) {
   return serializeWithPrimitiveFastPath(value);
@@ -231,16 +318,21 @@ function defaultDeserialize(value) {
   return deserializeWithPrimitiveFastPath(value);
 }
 export function createStorageItem(config) {
+  const storageKey = prefixKey(config.namespace, config.key);
   const serialize = config.serialize ?? defaultSerialize;
   const deserialize = config.deserialize ?? defaultDeserialize;
   const isMemory = config.scope === StorageScope.Memory;
+  const isBiometric = config.biometric === true && config.scope === StorageScope.Secure;
+  const secureAccessControl = config.accessControl;
   const validate = config.validate;
   const onValidationError = config.onValidationError;
   const expiration = config.expiration;
+  const onExpired = config.onExpired;
   const expirationTtlMs = expiration?.ttlMs;
   const memoryExpiration = expiration && isMemory ? new Map() : null;
   const readCache = !isMemory && config.readCache === true;
-  const coalesceSecureWrites = config.scope === StorageScope.Secure && config.coalesceSecureWrites === true;
+  const coalesceSecureWrites = config.scope === StorageScope.Secure && config.coalesceSecureWrites === true && !isBiometric && secureAccessControl === undefined;
+  const defaultValue = config.defaultValue;
   const nonMemoryScope = config.scope === StorageScope.Disk ? StorageScope.Disk : config.scope === StorageScope.Secure ? StorageScope.Secure : null;
   if (expiration && expiration.ttlMs <= 0) {
     throw new Error("expiration.ttlMs must be greater than 0.");
@@ -250,10 +342,12 @@ export function createStorageItem(config) {
   let lastRaw = undefined;
   let lastValue;
   let hasLastValue = false;
+  let lastExpiresAt = undefined;
   const invalidateParsedCache = () => {
     lastRaw = undefined;
     lastValue = undefined;
     hasLastValue = false;
+    lastExpiresAt = undefined;
   };
   const ensureSubscription = () => {
     if (unsubscribe) {
@@ -264,66 +358,79 @@ export function createStorageItem(config) {
       listeners.forEach(callback => callback());
     };
     if (isMemory) {
-      unsubscribe = addKeyListener(memoryListeners, config.key, listener);
+      unsubscribe = addKeyListener(memoryListeners, storageKey, listener);
       return;
     }
     ensureNativeScopeSubscription(nonMemoryScope);
-    unsubscribe = addKeyListener(getScopedListeners(nonMemoryScope), config.key, listener);
+    unsubscribe = addKeyListener(getScopedListeners(nonMemoryScope), storageKey, listener);
   };
   const readStoredRaw = () => {
     if (isMemory) {
       if (memoryExpiration) {
-        const expiresAt = memoryExpiration.get(config.key);
+        const expiresAt = memoryExpiration.get(storageKey);
         if (expiresAt !== undefined && expiresAt <= Date.now()) {
-          memoryExpiration.delete(config.key);
-          memoryStore.delete(config.key);
-          notifyKeyListeners(memoryListeners, config.key);
+          memoryExpiration.delete(storageKey);
+          memoryStore.delete(storageKey);
+          notifyKeyListeners(memoryListeners, storageKey);
+          onExpired?.(storageKey);
           return undefined;
         }
       }
-      return memoryStore.get(config.key);
+      return memoryStore.get(storageKey);
     }
-    if (nonMemoryScope === StorageScope.Secure && hasPendingSecureWrite(config.key)) {
-      return readPendingSecureWrite(config.key);
+    if (nonMemoryScope === StorageScope.Secure && !isBiometric && hasPendingSecureWrite(storageKey)) {
+      return readPendingSecureWrite(storageKey);
     }
     if (readCache) {
-      if (hasCachedRawValue(nonMemoryScope, config.key)) {
-        return readCachedRawValue(nonMemoryScope, config.key);
+      if (hasCachedRawValue(nonMemoryScope, storageKey)) {
+        return readCachedRawValue(nonMemoryScope, storageKey);
       }
     }
-    const raw = getStorageModule().get(config.key, config.scope);
-    cacheRawValue(nonMemoryScope, config.key, raw);
+    if (isBiometric) {
+      return getStorageModule().getSecureBiometric(storageKey);
+    }
+    const raw = getStorageModule().get(storageKey, config.scope);
+    cacheRawValue(nonMemoryScope, storageKey, raw);
     return raw;
   };
   const writeStoredRaw = rawValue => {
-    cacheRawValue(nonMemoryScope, config.key, rawValue);
+    if (isBiometric) {
+      getStorageModule().setSecureBiometric(storageKey, rawValue);
+      return;
+    }
+    cacheRawValue(nonMemoryScope, storageKey, rawValue);
     if (coalesceSecureWrites) {
-      scheduleSecureWrite(config.key, rawValue);
+      scheduleSecureWrite(storageKey, rawValue);
       return;
     }
     if (nonMemoryScope === StorageScope.Secure) {
-      clearPendingSecureWrite(config.key);
+      clearPendingSecureWrite(storageKey);
+      getStorageModule().setSecureAccessControl(secureAccessControl ?? secureDefaultAccessControl);
     }
-    getStorageModule().set(config.key, rawValue, config.scope);
+    getStorageModule().set(storageKey, rawValue, config.scope);
   };
   const removeStoredRaw = () => {
-    cacheRawValue(nonMemoryScope, config.key, undefined);
+    if (isBiometric) {
+      getStorageModule().deleteSecureBiometric(storageKey);
+      return;
+    }
+    cacheRawValue(nonMemoryScope, storageKey, undefined);
     if (coalesceSecureWrites) {
-      scheduleSecureWrite(config.key, undefined);
+      scheduleSecureWrite(storageKey, undefined);
       return;
     }
     if (nonMemoryScope === StorageScope.Secure) {
-      clearPendingSecureWrite(config.key);
+      clearPendingSecureWrite(storageKey);
     }
-    getStorageModule().remove(config.key, config.scope);
+    getStorageModule().remove(storageKey, config.scope);
   };
   const writeValueWithoutValidation = value => {
     if (isMemory) {
       if (memoryExpiration) {
-        memoryExpiration.set(config.key, Date.now() + (expirationTtlMs ?? 0));
+        memoryExpiration.set(storageKey, Date.now() + (expirationTtlMs ?? 0));
       }
-      memoryStore.set(config.key, value);
-      notifyKeyListeners(memoryListeners, config.key);
+      memoryStore.set(storageKey, value);
+      notifyKeyListeners(memoryListeners, storageKey);
       return;
     }
     const serialized = serialize(value);
@@ -342,7 +449,7 @@ export function createStorageItem(config) {
     if (onValidationError) {
       return onValidationError(invalidValue);
     }
-    return config.defaultValue;
+    return defaultValue;
   };
   const ensureValidatedValue = (candidate, hadStoredValue) => {
     if (!validate || validate(candidate)) {
@@ -350,7 +457,7 @@ export function createStorageItem(config) {
     }
     const resolved = resolveInvalidValue(candidate);
     if (validate && !validate(resolved)) {
-      return config.defaultValue;
+      return defaultValue;
     }
     if (hadStoredValue) {
       writeValueWithoutValidation(resolved);
@@ -359,30 +466,53 @@ export function createStorageItem(config) {
   };
   const get = () => {
     const raw = readStoredRaw();
-    const canUseCachedValue = !expiration && !memoryExpiration;
-    if (canUseCachedValue && raw === lastRaw && hasLastValue) {
-      return lastValue;
+    if (!memoryExpiration && raw === lastRaw && hasLastValue) {
+      if (!expiration || lastExpiresAt === null) {
+        return lastValue;
+      }
+      if (typeof lastExpiresAt === "number") {
+        if (lastExpiresAt > Date.now()) {
+          return lastValue;
+        }
+        removeStoredRaw();
+        invalidateParsedCache();
+        onExpired?.(storageKey);
+        lastValue = ensureValidatedValue(defaultValue, false);
+        hasLastValue = true;
+        return lastValue;
+      }
     }
     lastRaw = raw;
     if (raw === undefined) {
-      lastValue = ensureValidatedValue(config.defaultValue, false);
+      lastExpiresAt = undefined;
+      lastValue = ensureValidatedValue(defaultValue, false);
       hasLastValue = true;
       return lastValue;
     }
     if (isMemory) {
+      lastExpiresAt = undefined;
       lastValue = ensureValidatedValue(raw, true);
       hasLastValue = true;
       return lastValue;
     }
+    if (typeof raw !== "string") {
+      lastExpiresAt = undefined;
+      lastValue = ensureValidatedValue(defaultValue, false);
+      hasLastValue = true;
+      return lastValue;
+    }
     let deserializableRaw = raw;
     if (expiration) {
+      let envelopeExpiresAt = null;
       try {
         const parsed = JSON.parse(raw);
         if (isStoredEnvelope(parsed)) {
+          envelopeExpiresAt = parsed.expiresAt;
           if (parsed.expiresAt <= Date.now()) {
             removeStoredRaw();
             invalidateParsedCache();
-            lastValue = ensureValidatedValue(config.defaultValue, false);
+            onExpired?.(storageKey);
+            lastValue = ensureValidatedValue(defaultValue, false);
             hasLastValue = true;
             return lastValue;
           }
@@ -391,17 +521,19 @@ export function createStorageItem(config) {
       } catch {
         // Keep backward compatibility with legacy raw values.
       }
+      lastExpiresAt = envelopeExpiresAt;
+    } else {
+      lastExpiresAt = undefined;
     }
     lastValue = ensureValidatedValue(deserialize(deserializableRaw), true);
     hasLastValue = true;
     return lastValue;
   };
   const set = valueOrFn => {
-    const currentValue = get();
-    const newValue = typeof valueOrFn === "function" ? valueOrFn(currentValue) : valueOrFn;
+    const newValue = isUpdater(valueOrFn) ? valueOrFn(get()) : valueOrFn;
     invalidateParsedCache();
     if (validate && !validate(newValue)) {
-      throw new Error(`Validation failed for key "${config.key}" in scope "${StorageScope[config.scope]}".`);
+      throw new Error(`Validation failed for key "${storageKey}" in scope "${StorageScope[config.scope]}".`);
     }
     writeValueWithoutValidation(newValue);
   };
@@ -409,14 +541,19 @@ export function createStorageItem(config) {
     invalidateParsedCache();
     if (isMemory) {
       if (memoryExpiration) {
-        memoryExpiration.delete(config.key);
+        memoryExpiration.delete(storageKey);
       }
-      memoryStore.delete(config.key);
-      notifyKeyListeners(memoryListeners, config.key);
+      memoryStore.delete(storageKey);
+      notifyKeyListeners(memoryListeners, storageKey);
       return;
     }
     removeStoredRaw();
   };
+  const hasItem = () => {
+    if (isMemory) return memoryStore.has(storageKey);
+    if (isBiometric) return getStorageModule().hasSecureBiometric(storageKey);
+    return getStorageModule().has(storageKey, config.scope);
+  };
   const subscribe = callback => {
     ensureSubscription();
     listeners.add(callback);
@@ -435,6 +572,7 @@ export function createStorageItem(config) {
     get,
     set,
     delete: deleteItem,
+    has: hasItem,
     subscribe,
     serialize,
     deserialize,
@@ -445,43 +583,22 @@ export function createStorageItem(config) {
     _hasValidation: validate !== undefined,
     _hasExpiration: expiration !== undefined,
     _readCacheEnabled: readCache,
+    _isBiometric: isBiometric,
+    ...(secureAccessControl !== undefined ? {
+      _secureAccessControl: secureAccessControl
+    } : {}),
     scope: config.scope,
-    key: config.key
+    key: storageKey
   };
   return storageItem;
 }
-export function useStorage(item) {
-  const value = useSyncExternalStore(item.subscribe, item.get, item.get);
-  return [value, item.set];
-}
-export function useStorageSelector(item, selector, isEqual = Object.is) {
-  const selectedRef = useRef({
-    hasValue: false
-  });
-  const getSelectedSnapshot = () => {
-    const nextSelected = selector(item.get());
-    const current = selectedRef.current;
-    if (current.hasValue && isEqual(current.value, nextSelected)) {
-      return current.value;
-    }
-    selectedRef.current = {
-      hasValue: true,
-      value: nextSelected
-    };
-    return nextSelected;
-  };
-  const selectedValue = useSyncExternalStore(item.subscribe, getSelectedSnapshot, getSelectedSnapshot);
-  return [selectedValue, item.set];
-}
-export function useSetStorage(item) {
-  return item.set;
-}
+export { useStorage, useStorageSelector, useSetStorage } from "./storage-hooks";
 export function getBatch(items, scope) {
   assertBatchScope(items, scope);
   if (scope === StorageScope.Memory) {
     return items.map(item => item.get());
   }
-  const useRawBatchPath = items.every(item => canUseRawBatchPath(item));
+  const useRawBatchPath = items.every(item => scope === StorageScope.Secure ? canUseSecureRawBatchPath(item) : canUseRawBatchPath(item));
   if (!useRawBatchPath) {
     return items.map(item => item.get());
   }
@@ -510,6 +627,9 @@ export function getBatch(items, scope) {
     fetchedValues.forEach((value, index) => {
       const key = keysToFetch[index];
       const targetIndex = keyIndexes[index];
+      if (key === undefined || targetIndex === undefined) {
+        return;
+      }
       rawValues[targetIndex] = value;
       cacheRawValue(scope, key, value);
     });
@@ -531,9 +651,55 @@ export function setBatch(items, scope) {
     }) => item.set(value));
     return;
   }
+  if (scope === StorageScope.Secure) {
+    const secureEntries = items.map(({
+      item,
+      value
+    }) => ({
+      item,
+      value,
+      internal: asInternal(item)
+    }));
+    const canUseSecureBatchPath = secureEntries.every(({
+      internal
+    }) => canUseSecureRawBatchPath(internal));
+    if (!canUseSecureBatchPath) {
+      items.forEach(({
+        item,
+        value
+      }) => item.set(value));
+      return;
+    }
+    flushSecureWrites();
+    const storageModule = getStorageModule();
+    const groupedByAccessControl = new Map();
+    secureEntries.forEach(({
+      item,
+      value,
+      internal
+    }) => {
+      const accessControl = internal._secureAccessControl ?? secureDefaultAccessControl;
+      const existingGroup = groupedByAccessControl.get(accessControl);
+      const group = existingGroup ?? {
+        keys: [],
+        values: []
+      };
+      group.keys.push(item.key);
+      group.values.push(item.serialize(value));
+      if (!existingGroup) {
+        groupedByAccessControl.set(accessControl, group);
+      }
+    });
+    groupedByAccessControl.forEach((group, accessControl) => {
+      storageModule.setSecureAccessControl(accessControl);
+      storageModule.setBatch(group.keys, group.values, scope);
+      group.keys.forEach((key, index) => cacheRawValue(scope, key, group.values[index]));
+    });
+    return;
+  }
   const useRawBatchPath = items.every(({
     item
-  }) => canUseRawBatchPath(item));
+  }) => canUseRawBatchPath(asInternal(item)));
   if (!useRawBatchPath) {
     items.forEach(({
       item,
@@ -543,9 +709,6 @@ export function setBatch(items, scope) {
   }
   const keys = items.map(entry => entry.item.key);
   const values = items.map(entry => entry.item.serialize(entry.value));
-  if (scope === StorageScope.Secure) {
-    flushSecureWrites();
-  }
   getStorageModule().setBatch(keys, values, scope);
   keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
 }
@@ -644,4 +807,30 @@ export function runTransaction(scope, transaction) {
     throw error;
   }
 }
+export function createSecureAuthStorage(config, options) {
+  const ns = options?.namespace ?? "auth";
+  const result = {};
+  for (const key of typedKeys(config)) {
+    const itemConfig = config[key];
+    const expirationConfig = itemConfig.ttlMs !== undefined ? {
+      ttlMs: itemConfig.ttlMs
+    } : undefined;
+    result[key] = createStorageItem({
+      key,
+      scope: StorageScope.Secure,
+      defaultValue: "",
+      namespace: ns,
+      ...(itemConfig.biometric !== undefined ? {
+        biometric: itemConfig.biometric
+      } : {}),
+      ...(itemConfig.accessControl !== undefined ? {
+        accessControl: itemConfig.accessControl
+      } : {}),
+      ...(expirationConfig !== undefined ? {
+        expiration: expirationConfig
+      } : {})
+    });
+  }
+  return result;
+}
 //# sourceMappingURL=index.js.map