react-native-nitro-storage 0.5.9 → 0.7.0

package/lib/module/storage-core.js

@@ -1,14 +1,17 @@
 "use strict";
 
-import { assertAccessControlLevel, assertBiometricLevel, canUseRawBatchPath, canUseSecureRawBatchPath, createKeyChange, defaultDeserialize, defaultSerialize, isUpdater, notifyAllListeners, notifyKeyListeners, now, redactSecureKeyChange, runMicrotask, typedKeys } from "./shared";
+import { assertAccessControlLevel, assertBiometricLevel, canUseRawBatchPath, canUseSecureRawBatchPath, createKeyChange, defaultDeserialize, defaultSerialize, isKeychainLockedError, isUpdater, notifyAllListeners, notifyKeyListeners, now, redactSecureKeyChange, runMicrotask, typedKeys } from "./shared";
 import { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
 import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, toVersionToken, prefixKey, isNamespaced } from "./internal";
 import { StorageEventRegistry } from "./storage-events";
+const EMPTY_KEYS = Object.freeze([]);
 function asInternal(item) {
   return item;
 }
 export function createStorageCore(buildAdapter) {
   const registeredMigrations = new Map();
+  const itemGroups = new Map();
+  const registeredKeyCounts = new Map();
   const memoryStore = new Map();
   const memoryListeners = new Map();
   const scopedListeners = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
@@ -355,6 +358,40 @@ export function createStorageCore(buildAdapter) {
     }
   };
   const adapter = buildAdapter(internals);
+  function resolveKeyRef(ref) {
+    return typeof ref === "string" ? ref : ref.key;
+  }
+  function clearScopeExcept(scope, exceptRefs) {
+    measureOperation("storage:clearExcept", scope, () => {
+      assertValidScope(scope);
+      const keep = new Set(exceptRefs.map(resolveKeyRef));
+      if (scope === StorageScope.Memory) {
+        const removeKeys = Array.from(memoryStore.keys()).filter(key => !keep.has(key));
+        if (removeKeys.length === 0) {
+          return;
+        }
+        const previousValues = shouldReadPreviousEventValues(scope) ? removeKeys.map(key => getEventRawValue(scope, key)) : [];
+        removeKeys.forEach(key => memoryStore.delete(key));
+        removeKeys.forEach(key => notifyKeyListeners(memoryListeners, key));
+        emitBatchChange(scope, "clear", "memory", removeKeys.map((key, index) => createKeyChange(scope, key, previousValues[index], undefined, "clear", "memory")));
+        return;
+      }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === StorageScope.Secure) {
+        flushSecureWrites();
+      }
+      const removeKeys = adapter.backend.getAllKeys(scope).filter(key => !keep.has(key));
+      if (removeKeys.length === 0) {
+        return;
+      }
+      const previousValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(removeKeys, scope) : [];
+      adapter.backend.removeBatch(removeKeys, scope);
+      removeKeys.forEach(key => cacheRawValue(scope, key, undefined));
+      emitBatchChange(scope, "clear", adapter.changeSource, removeKeys.map((key, index) => createKeyChange(scope, key, previousValues[index], undefined, "clear", adapter.changeSource)));
+    });
+  }
   const storage = {
     subscribe: (scope, listener) => {
       assertValidScope(scope);
@@ -406,7 +443,11 @@ export function createStorageCore(buildAdapter) {
       adapter.maybeCleanupScopeSubscription(StorageScope.Disk);
       adapter.maybeCleanupScopeSubscription(StorageScope.Secure);
     },
-    clear: scope => {
+    clear: (scope, options) => {
+      if (options?.except && options.except.length > 0) {
+        clearScopeExcept(scope, options.except);
+        return;
+      }
       measureOperation("storage:clear", scope, () => {
         const previousValues = shouldReadPreviousEventValues(scope) ? storage.getAll(scope) : {};
         if (scope === StorageScope.Memory) {
@@ -435,6 +476,71 @@ export function createStorageCore(buildAdapter) {
         storage.clear(StorageScope.Secure);
       }, 3);
     },
+    clearGroup: group => {
+      const items = itemGroups.get(group);
+      if (!items || items.size === 0) {
+        return;
+      }
+      measureOperation("storage:clearGroup", StorageScope.Memory, () => {
+        const byScope = new Map();
+        for (const item of items) {
+          const scoped = byScope.get(item.scope);
+          if (scoped) {
+            scoped.push(item);
+          } else {
+            byScope.set(item.scope, [item]);
+          }
+        }
+        byScope.forEach((groupItems, scope) => {
+          removeBatch(groupItems, scope);
+        });
+      }, items.size);
+    },
+    getGroupItems: group => {
+      const items = itemGroups.get(group);
+      return items ? Array.from(items) : [];
+    },
+    subscribeExpired: (scope, listener) => {
+      return storage.subscribe(scope, event => {
+        if (event.type === "key") {
+          if (event.operation === "expire") {
+            listener(event);
+          }
+          return;
+        }
+        event.changes.forEach(change => {
+          if (change.operation === "expire") {
+            listener(change);
+          }
+        });
+      });
+    },
+    findDuplicateKeys: () => {
+      const duplicates = [];
+      registeredKeyCounts.forEach((count, registryKey) => {
+        if (count <= 1) {
+          return;
+        }
+        const separatorIndex = registryKey.indexOf(":");
+        duplicates.push({
+          scope: Number(registryKey.slice(0, separatorIndex)),
+          key: registryKey.slice(separatorIndex + 1),
+          count
+        });
+      });
+      return duplicates;
+    },
+    getRegisteredKeys: () => {
+      const result = [];
+      registeredKeyCounts.forEach((_count, registryKey) => {
+        const separatorIndex = registryKey.indexOf(":");
+        result.push({
+          scope: Number(registryKey.slice(0, separatorIndex)),
+          key: registryKey.slice(separatorIndex + 1)
+        });
+      });
+      return result;
+    },
     clearNamespace: (namespace, scope) => {
       measureOperation("storage:clearNamespace", scope, () => {
         assertValidScope(scope);
@@ -734,6 +840,10 @@ export function createStorageCore(buildAdapter) {
     const coalesceSecureWrites = config.scope === StorageScope.Secure && config.coalesceSecureWrites === true && !isBiometric;
     const defaultValue = config.defaultValue;
     const nonMemoryScope = config.scope === StorageScope.Disk ? StorageScope.Disk : config.scope === StorageScope.Secure ? StorageScope.Secure : null;
+    const renameFromKeys = config.renameFrom === undefined ? EMPTY_KEYS : typeof config.renameFrom === "string" ? [config.renameFrom] : config.renameFrom;
+    const fallbackToCacheOnReadError = config.fallbackToCacheOnReadError === true;
+    const onReadError = config.onReadError;
+    let renamesMigrated = isMemory || renameFromKeys.length === 0;
     if (expiration && expiration.ttlMs <= 0) {
       throw new Error("expiration.ttlMs must be greater than 0.");
     }
@@ -775,15 +885,18 @@ export function createStorageCore(buildAdapter) {
         if (memoryExpiration) {
           const expiresAt = memoryExpiration.get(storageKey);
           if (expiresAt !== undefined && expiresAt <= Date.now()) {
+            const expiredRaw = memoryStore.get(storageKey);
             memoryExpiration.delete(storageKey);
             memoryStore.delete(storageKey);
             notifyKeyListeners(memoryListeners, storageKey);
+            emitKeyChange(config.scope, storageKey, typeof expiredRaw === "string" ? expiredRaw : undefined, undefined, "expire", "memory");
             onExpired?.(storageKey);
             return undefined;
           }
         }
         return memoryStore.get(storageKey);
       }
+      migrateRenamesIfNeeded();
       if (nonMemoryScope === StorageScope.Disk) {
         const pending = pendingDiskWrites.get(storageKey);
         if (pending !== undefined) {
@@ -804,12 +917,27 @@ export function createStorageCore(buildAdapter) {
         }
       }
       if (isBiometric) {
-        return adapter.backend.getSecureBiometric(storageKey);
+        return readBackendRaw(() => adapter.backend.getSecureBiometric(storageKey));
       }
-      const raw = adapter.backend.get(storageKey, config.scope);
+      const raw = readBackendRaw(() => adapter.backend.get(storageKey, config.scope));
       cacheRawValue(nonMemoryScope, storageKey, raw);
       return raw;
     };
+    const readBackendRaw = read => {
+      try {
+        return read();
+      } catch (error) {
+        onReadError?.(error);
+        if (fallbackToCacheOnReadError) {
+          const cached = getScopeRawCache(nonMemoryScope).get(storageKey);
+          if (cached !== undefined) {
+            return cached;
+          }
+          return typeof lastRaw === "string" ? lastRaw : undefined;
+        }
+        throw error;
+      }
+    };
     const writeStoredRaw = rawValue => {
       const oldValue = undefined;
       if (isBiometric) {
@@ -840,32 +968,73 @@ export function createStorageCore(buildAdapter) {
       adapter.backend.set(storageKey, rawValue, config.scope);
       emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", adapter.changeSource);
     };
-    const removeStoredRaw = () => {
+    const migrateRenamesIfNeeded = () => {
+      if (renamesMigrated) {
+        return;
+      }
+      try {
+        const hasCurrent = isBiometric ? adapter.backend.hasSecureBiometric(storageKey) : adapter.backend.has(storageKey, config.scope);
+        if (hasCurrent) {
+          for (const legacyKey of renameFromKeys) {
+            if (isBiometric) {
+              if (adapter.backend.hasSecureBiometric(legacyKey)) {
+                adapter.backend.deleteSecureBiometric(legacyKey);
+              }
+            } else if (adapter.backend.has(legacyKey, config.scope)) {
+              adapter.backend.remove(legacyKey, config.scope);
+            }
+          }
+          renamesMigrated = true;
+          return;
+        }
+        for (const legacyKey of renameFromKeys) {
+          const legacyRaw = isBiometric ? adapter.backend.getSecureBiometric(legacyKey) : adapter.backend.get(legacyKey, config.scope);
+          if (legacyRaw === undefined) {
+            continue;
+          }
+          writeStoredRaw(legacyRaw);
+          if (isBiometric) {
+            adapter.backend.deleteSecureBiometric(legacyKey);
+          } else {
+            adapter.backend.remove(legacyKey, config.scope);
+          }
+          break;
+        }
+        renamesMigrated = true;
+      } catch (error) {
+        if (isKeychainLockedError(error)) {
+          onReadError?.(error);
+          return;
+        }
+        throw error;
+      }
+    };
+    const removeStoredRaw = (operation = "remove") => {
       const oldValue = getEventRawValue(config.scope, storageKey);
       if (isBiometric) {
         adapter.backend.deleteSecureBiometric(storageKey);
-        emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", adapter.changeSource);
+        emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
         return;
       }
       cacheRawValue(nonMemoryScope, storageKey, undefined);
       if (nonMemoryScope === StorageScope.Disk) {
         if (coalesceDiskWrites || diskWritesAsync) {
           scheduleDiskWrite(storageKey, undefined);
-          emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", adapter.changeSource);
+          emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
           return;
         }
         clearPendingDiskWrite(storageKey);
       }
       if (coalesceSecureWrites) {
         scheduleSecureWrite(storageKey, undefined, secureAccessControl ?? secureDefaultAccessControl);
-        emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", adapter.changeSource);
+        emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
         return;
       }
       if (nonMemoryScope === StorageScope.Secure) {
         clearPendingSecureWrite(storageKey);
       }
       adapter.backend.remove(storageKey, config.scope);
-      emitKeyChange(config.scope, storageKey, oldValue, undefined, "remove", adapter.changeSource);
+      emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
     };
     const writeValueWithoutValidation = value => {
       if (isMemory) {
@@ -919,7 +1088,7 @@ export function createStorageCore(buildAdapter) {
           if (lastExpiresAt > Date.now()) {
             return lastValue;
           }
-          removeStoredRaw();
+          removeStoredRaw("expire");
           invalidateParsedCache();
           onExpired?.(storageKey);
           lastValue = ensureValidatedValue(defaultValue, false);
@@ -955,7 +1124,7 @@ export function createStorageCore(buildAdapter) {
           if (isStoredEnvelope(parsed)) {
             envelopeExpiresAt = parsed.expiresAt;
             if (parsed.expiresAt <= Date.now()) {
-              removeStoredRaw();
+              removeStoredRaw("expire");
               invalidateParsedCache();
               onExpired?.(storageKey);
               lastValue = ensureValidatedValue(defaultValue, false);
@@ -1019,6 +1188,27 @@ export function createStorageCore(buildAdapter) {
         removeStoredRaw();
       });
     };
+    const merge = partial => {
+      set(prev => {
+        if (prev === null || typeof prev !== "object") {
+          return partial;
+        }
+        return {
+          ...prev,
+          ...partial
+        };
+      });
+    };
+    const reset = () => {
+      deleteItem();
+    };
+    const setOrDelete = value => {
+      if (value === null || value === undefined) {
+        deleteItem();
+        return;
+      }
+      set(value);
+    };
     const hasItem = () => measureOperation("item:has", config.scope, () => {
       if (isMemory) return memoryStore.has(storageKey);
       if (isBiometric) return adapter.backend.hasSecureBiometric(storageKey);
@@ -1071,6 +1261,9 @@ export function createStorageCore(buildAdapter) {
       getWithVersion,
       set,
       setIfVersion,
+      merge,
+      reset,
+      setOrDelete,
       delete: deleteItem,
       has: hasItem,
       subscribe,
@@ -1093,9 +1286,22 @@ export function createStorageCore(buildAdapter) {
       ...(secureAccessControl !== undefined ? {
         _secureAccessControl: secureAccessControl
       } : {}),
+      ...(config.group !== undefined ? {
+        _group: config.group
+      } : {}),
       scope: config.scope,
       key: storageKey
     };
+    if (config.group !== undefined) {
+      let groupSet = itemGroups.get(config.group);
+      if (!groupSet) {
+        groupSet = new Set();
+        itemGroups.set(config.group, groupSet);
+      }
+      groupSet.add(storageItem);
+    }
+    const registryKey = `${config.scope}:${storageKey}`;
+    registeredKeyCounts.set(registryKey, (registeredKeyCounts.get(registryKey) ?? 0) + 1);
     return storageItem;
   }
   function getBatch(items, scope) {
@@ -1480,14 +1686,104 @@ export function createStorageCore(buildAdapter) {
         } : {}),
         ...(expirationConfig !== undefined ? {
           expiration: expirationConfig
+        } : {}),
+        ...(itemConfig.renameFrom !== undefined ? {
+          renameFrom: itemConfig.renameFrom
+        } : {}),
+        ...(options?.group !== undefined ? {
+          group: options.group
+        } : {}),
+        ...(options?.fallbackToCacheOnReadError !== undefined ? {
+          fallbackToCacheOnReadError: options.fallbackToCacheOnReadError
         } : {})
       });
     }
     return result;
   }
+  function memoryItem(config) {
+    return createStorageItem({
+      ...config,
+      scope: StorageScope.Memory
+    });
+  }
+  function diskItem(config) {
+    return createStorageItem({
+      ...config,
+      scope: StorageScope.Disk
+    });
+  }
+  function secureItem(config) {
+    return createStorageItem({
+      ...config,
+      scope: StorageScope.Secure
+    });
+  }
+  function createSetItem(config) {
+    const {
+      defaultValue,
+      ...rest
+    } = config;
+    const initial = {};
+    if (defaultValue) {
+      for (const id of defaultValue) {
+        initial[id] = true;
+      }
+    }
+    const item = createStorageItem({
+      ...rest,
+      defaultValue: initial
+    });
+    const has = id => item.get()[id] === true;
+    const add = id => {
+      if (item.get()[id] === true) {
+        return;
+      }
+      item.merge({
+        [id]: true
+      });
+    };
+    const deleteId = id => {
+      const current = item.get();
+      if (current[id] !== true) {
+        return;
+      }
+      const next = {
+        ...current
+      };
+      delete next[id];
+      item.set(next);
+    };
+    const toggle = id => {
+      if (has(id)) {
+        deleteId(id);
+        return false;
+      }
+      add(id);
+      return true;
+    };
+    return {
+      get: item.get,
+      has,
+      add,
+      delete: deleteId,
+      toggle,
+      values: () => Object.keys(item.get()),
+      size: () => Object.keys(item.get()).length,
+      clear: () => item.set({}),
+      reset: item.reset,
+      subscribe: item.subscribe,
+      scope: item.scope,
+      key: item.key,
+      item
+    };
+  }
   return {
     storage,
     createStorageItem,
+    memoryItem,
+    diskItem,
+    secureItem,
+    createSetItem,
     getBatch,
     setBatch,
     removeBatch,