react-native-nitro-storage 0.3.1 → 0.3.2

package/lib/module/index.web.js

@@ -1,13 +1,18 @@
 "use strict";
 
-import { useRef, useSyncExternalStore } from "react";
-import { StorageScope } from "./Storage.types";
+import { StorageScope, AccessControl } from "./Storage.types";
 import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, 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);
@@ -16,6 +21,8 @@ const memoryStore = new Map();
 const memoryListeners = new Map();
 const webScopeListeners = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
 const scopedRawCache = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
+const webScopeKeyIndex = new Map([[StorageScope.Disk, new Set()], [StorageScope.Secure, new Set()]]);
+const hydratedWebScopeKeyIndex = new Set();
 const pendingSecureWrites = new Map();
 let secureFlushScheduled = false;
 const SECURE_WEB_PREFIX = "__secure_";
@@ -42,6 +49,43 @@ function toBiometricStorageKey(key) {
 function fromBiometricStorageKey(key) {
   return key.slice(BIOMETRIC_WEB_PREFIX.length);
 }
+function getWebScopeKeyIndex(scope) {
+  return webScopeKeyIndex.get(scope);
+}
+function hydrateWebScopeKeyIndex(scope) {
+  if (hydratedWebScopeKeyIndex.has(scope)) {
+    return;
+  }
+  const storage = getBrowserStorage(scope);
+  const keyIndex = getWebScopeKeyIndex(scope);
+  keyIndex.clear();
+  if (storage) {
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (!key) {
+        continue;
+      }
+      if (scope === StorageScope.Disk) {
+        if (!key.startsWith(SECURE_WEB_PREFIX) && !key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+          keyIndex.add(key);
+        }
+        continue;
+      }
+      if (key.startsWith(SECURE_WEB_PREFIX)) {
+        keyIndex.add(fromSecureStorageKey(key));
+        continue;
+      }
+      if (key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+        keyIndex.add(fromBiometricStorageKey(key));
+      }
+    }
+  }
+  hydratedWebScopeKeyIndex.add(scope);
+}
+function ensureWebScopeKeyIndex(scope) {
+  hydrateWebScopeKeyIndex(scope);
+  return getWebScopeKeyIndex(scope);
+}
 function getScopedListeners(scope) {
   return webScopeListeners.get(scope);
 }
@@ -146,6 +190,7 @@ const WebStorage = {
     const storageKey = scope === StorageScope.Secure ? toSecureStorageKey(key) : key;
     storage.setItem(storageKey, value);
     if (scope === StorageScope.Disk || scope === StorageScope.Secure) {
+      ensureWebScopeKeyIndex(scope).add(key);
       notifyKeyListeners(getScopedListeners(scope), key);
     }
   },
@@ -166,6 +211,7 @@ const WebStorage = {
       storage.removeItem(key);
     }
     if (scope === StorageScope.Disk || scope === StorageScope.Secure) {
+      ensureWebScopeKeyIndex(scope).delete(key);
       notifyKeyListeners(getScopedListeners(scope), key);
     }
   },
@@ -196,6 +242,7 @@ const WebStorage = {
       storage.clear();
     }
     if (scope === StorageScope.Disk || scope === StorageScope.Secure) {
+      ensureWebScopeKeyIndex(scope).clear();
       notifyAllListeners(getScopedListeners(scope));
     }
   },
@@ -205,10 +252,16 @@ const WebStorage = {
       return;
     }
     keys.forEach((key, index) => {
+      const value = values[index];
+      if (value === undefined) {
+        return;
+      }
       const storageKey = scope === StorageScope.Secure ? toSecureStorageKey(key) : key;
-      storage.setItem(storageKey, values[index]);
+      storage.setItem(storageKey, value);
     });
     if (scope === StorageScope.Disk || scope === StorageScope.Secure) {
+      const keyIndex = ensureWebScopeKeyIndex(scope);
+      keys.forEach(key => keyIndex.add(key));
       const listeners = getScopedListeners(scope);
       keys.forEach(key => notifyKeyListeners(listeners, key));
     }
@@ -221,9 +274,37 @@ const WebStorage = {
     });
   },
   removeBatch: (keys, scope) => {
-    keys.forEach(key => {
-      WebStorage.remove(key, scope);
-    });
+    const storage = getBrowserStorage(scope);
+    if (!storage) {
+      return;
+    }
+    if (scope === StorageScope.Secure) {
+      keys.forEach(key => {
+        storage.removeItem(toSecureStorageKey(key));
+        storage.removeItem(toBiometricStorageKey(key));
+      });
+    } else {
+      keys.forEach(key => {
+        storage.removeItem(key);
+      });
+    }
+    if (scope === StorageScope.Disk || scope === StorageScope.Secure) {
+      const keyIndex = ensureWebScopeKeyIndex(scope);
+      keys.forEach(key => keyIndex.delete(key));
+      const listeners = getScopedListeners(scope);
+      keys.forEach(key => notifyKeyListeners(listeners, key));
+    }
+  },
+  removeByPrefix: (prefix, scope) => {
+    if (scope !== StorageScope.Disk && scope !== StorageScope.Secure) {
+      return;
+    }
+    const keyIndex = ensureWebScopeKeyIndex(scope);
+    const keys = Array.from(keyIndex).filter(key => key.startsWith(prefix));
+    if (keys.length === 0) {
+      return;
+    }
+    WebStorage.removeBatch(keys, scope);
   },
   addOnChange: (_scope, _callback) => {
     return () => {};
@@ -236,33 +317,19 @@ const WebStorage = {
     return storage?.getItem(key) !== null;
   },
   getAllKeys: scope => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) return [];
-    const keys = new Set();
-    for (let i = 0; i < storage.length; i++) {
-      const k = storage.key(i);
-      if (!k) {
-        continue;
-      }
-      if (scope === StorageScope.Secure) {
-        if (k.startsWith(SECURE_WEB_PREFIX)) {
-          keys.add(fromSecureStorageKey(k));
-        } else if (k.startsWith(BIOMETRIC_WEB_PREFIX)) {
-          keys.add(fromBiometricStorageKey(k));
-        }
-        continue;
-      }
-      if (k.startsWith(SECURE_WEB_PREFIX) || k.startsWith(BIOMETRIC_WEB_PREFIX)) {
-        continue;
-      }
-      keys.add(k);
+    if (scope !== StorageScope.Disk && scope !== StorageScope.Secure) {
+      return [];
     }
-    return Array.from(keys);
+    return Array.from(ensureWebScopeKeyIndex(scope));
   },
   size: scope => {
-    return WebStorage.getAllKeys(scope).length;
+    if (scope === StorageScope.Disk || scope === StorageScope.Secure) {
+      return ensureWebScopeKeyIndex(scope).size;
+    }
+    return 0;
   },
   setSecureAccessControl: () => {},
+  setSecureWritesAsync: _enabled => {},
   setKeychainAccessGroup: () => {},
   setSecureBiometric: (key, value) => {
     if (typeof __DEV__ !== "undefined" && __DEV__ && !hasWarnedAboutWebBiometricFallback) {
@@ -270,13 +337,18 @@ const WebStorage = {
       console.warn("[NitroStorage] Biometric storage is not supported on web. Using localStorage.");
     }
     globalThis.localStorage?.setItem(toBiometricStorageKey(key), value);
+    ensureWebScopeKeyIndex(StorageScope.Secure).add(key);
     notifyKeyListeners(getScopedListeners(StorageScope.Secure), key);
   },
   getSecureBiometric: key => {
     return globalThis.localStorage?.getItem(toBiometricStorageKey(key)) ?? undefined;
   },
   deleteSecureBiometric: key => {
-    globalThis.localStorage?.removeItem(toBiometricStorageKey(key));
+    const storage = globalThis.localStorage;
+    storage?.removeItem(toBiometricStorageKey(key));
+    if (storage?.getItem(toSecureStorageKey(key)) === null) {
+      ensureWebScopeKeyIndex(StorageScope.Secure).delete(key);
+    }
     notifyKeyListeners(getScopedListeners(StorageScope.Secure), key);
   },
   hasSecureBiometric: key => {
@@ -295,6 +367,12 @@ const WebStorage = {
       }
     }
     toRemove.forEach(k => storage.removeItem(k));
+    const keyIndex = ensureWebScopeKeyIndex(StorageScope.Secure);
+    keysToNotify.forEach(key => {
+      if (storage.getItem(toSecureStorageKey(key)) === null) {
+        keyIndex.delete(key);
+      }
+    });
     const listeners = getScopedListeners(StorageScope.Secure);
     keysToNotify.forEach(key => notifyKeyListeners(listeners, key));
   }
@@ -362,9 +440,6 @@ export const storage = {
     }
     clearScopeRawCache(scope);
     WebStorage.clear(scope);
-    if (scope === StorageScope.Secure) {
-      WebStorage.clearSecureBiometric();
-    }
   },
   clearAll: () => {
     storage.clear(StorageScope.Memory);
@@ -382,18 +457,12 @@ export const storage = {
       notifyAllListeners(memoryListeners);
       return;
     }
+    const keyPrefix = prefixKey(namespace, "");
     if (scope === StorageScope.Secure) {
       flushSecureWrites();
     }
-    const keys = WebStorage.getAllKeys(scope);
-    const namespacedKeys = keys.filter(k => isNamespaced(k, namespace));
-    if (namespacedKeys.length > 0) {
-      WebStorage.removeBatch(namespacedKeys, scope);
-      namespacedKeys.forEach(k => cacheRawValue(scope, k, undefined));
-      if (scope === StorageScope.Secure) {
-        namespacedKeys.forEach(k => clearPendingSecureWrite(k));
-      }
-    }
+    clearScopeRawCache(scope);
+    WebStorage.removeByPrefix(keyPrefix, scope);
   },
   clearBiometric: () => {
     WebStorage.clearSecureBiometric();
@@ -430,11 +499,18 @@ export const storage = {
     return WebStorage.size(scope);
   },
   setAccessControl: _level => {},
+  setSecureWritesAsync: _enabled => {},
+  flushSecureWrites: () => {
+    flushSecureWrites();
+  },
   setKeychainAccessGroup: _group => {}
 };
 function canUseRawBatchPath(item) {
   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);
 }
@@ -456,6 +532,7 @@ export function createStorageItem(config) {
   const memoryExpiration = expiration && isMemory ? new Map() : null;
   const readCache = !isMemory && config.readCache === 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.");
@@ -465,10 +542,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) {
@@ -568,7 +647,7 @@ export function createStorageItem(config) {
     if (onValidationError) {
       return onValidationError(invalidValue);
     }
-    return config.defaultValue;
+    return defaultValue;
   };
   const ensureValidatedValue = (candidate, hadStoredValue) => {
     if (!validate || validate(candidate)) {
@@ -576,7 +655,7 @@ export function createStorageItem(config) {
     }
     const resolved = resolveInvalidValue(candidate);
     if (validate && !validate(resolved)) {
-      return config.defaultValue;
+      return defaultValue;
     }
     if (hadStoredValue) {
       writeValueWithoutValidation(resolved);
@@ -585,31 +664,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();
             onExpired?.(storageKey);
-            lastValue = ensureValidatedValue(config.defaultValue, false);
+            lastValue = ensureValidatedValue(defaultValue, false);
             hasLastValue = true;
             return lastValue;
           }
@@ -618,14 +719,16 @@ 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 "${storageKey}" in scope "${StorageScope[config.scope]}".`);
@@ -676,44 +779,21 @@ export function createStorageItem(config) {
     _hasExpiration: expiration !== undefined,
     _readCacheEnabled: readCache,
     _isBiometric: isBiometric,
-    _secureAccessControl: secureAccessControl,
+    ...(secureAccessControl !== undefined ? {
+      _secureAccessControl: secureAccessControl
+    } : {}),
     scope: config.scope,
     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());
   }
@@ -742,6 +822,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);
     });
@@ -763,6 +846,51 @@ 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 groupedByAccessControl = new Map();
+    secureEntries.forEach(({
+      item,
+      value,
+      internal
+    }) => {
+      const accessControl = internal._secureAccessControl ?? AccessControl.WhenUnlocked;
+      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) => {
+      WebStorage.setSecureAccessControl(accessControl);
+      WebStorage.setBatch(group.keys, group.values, scope);
+      group.keys.forEach((key, index) => cacheRawValue(scope, key, group.values[index]));
+    });
+    return;
+  }
   const useRawBatchPath = items.every(({
     item
   }) => canUseRawBatchPath(asInternal(item)));
@@ -775,9 +903,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();
-  }
   WebStorage.setBatch(keys, values, scope);
   keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
 }
@@ -879,18 +1004,25 @@ export function runTransaction(scope, transaction) {
 export function createSecureAuthStorage(config, options) {
   const ns = options?.namespace ?? "auth";
   const result = {};
-  for (const key of Object.keys(config)) {
+  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,
-      biometric: itemConfig.biometric,
-      accessControl: itemConfig.accessControl,
-      expiration: itemConfig.ttlMs ? {
-        ttlMs: itemConfig.ttlMs
-      } : undefined
+      ...(itemConfig.biometric !== undefined ? {
+        biometric: itemConfig.biometric
+      } : {}),
+      ...(itemConfig.accessControl !== undefined ? {
+        accessControl: itemConfig.accessControl
+      } : {}),
+      ...(expirationConfig !== undefined ? {
+        expiration: expirationConfig
+      } : {})
     });
   }
   return result;