react-native-nitro-storage 0.3.0 → 0.3.1

package/lib/commonjs/index.web.js

@@ -3,12 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "AccessControl", {
+  enumerable: true,
+  get: function () {
+    return _Storage.AccessControl;
+  }
+});
+Object.defineProperty(exports, "BiometricLevel", {
+  enumerable: true,
+  get: function () {
+    return _Storage.BiometricLevel;
+  }
+});
 Object.defineProperty(exports, "StorageScope", {
   enumerable: true,
   get: function () {
     return _Storage.StorageScope;
   }
 });
+exports.createSecureAuthStorage = createSecureAuthStorage;
 exports.createStorageItem = createStorageItem;
 exports.getBatch = getBatch;
 Object.defineProperty(exports, "migrateFromMMKV", {
@@ -30,6 +43,9 @@ var _react = require("react");
 var _Storage = require("./Storage.types");
 var _internal = require("./internal");
 var _migration = require("./migration");
+function asInternal(item) {
+  return item;
+}
 const registeredMigrations = new Map();
 const runMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : task => {
   Promise.resolve().then(task);
@@ -40,15 +56,30 @@ const webScopeListeners = new Map([[_Storage.StorageScope.Disk, new Map()], [_St
 const scopedRawCache = new Map([[_Storage.StorageScope.Disk, new Map()], [_Storage.StorageScope.Secure, new Map()]]);
 const pendingSecureWrites = new Map();
 let secureFlushScheduled = false;
+const SECURE_WEB_PREFIX = "__secure_";
+const BIOMETRIC_WEB_PREFIX = "__bio_";
+let hasWarnedAboutWebBiometricFallback = false;
 function getBrowserStorage(scope) {
   if (scope === _Storage.StorageScope.Disk) {
     return globalThis.localStorage;
   }
   if (scope === _Storage.StorageScope.Secure) {
-    return globalThis.sessionStorage;
+    return globalThis.localStorage;
   }
   return undefined;
 }
+function toSecureStorageKey(key) {
+  return `${SECURE_WEB_PREFIX}${key}`;
+}
+function fromSecureStorageKey(key) {
+  return key.slice(SECURE_WEB_PREFIX.length);
+}
+function toBiometricStorageKey(key) {
+  return `${BIOMETRIC_WEB_PREFIX}${key}`;
+}
+function fromBiometricStorageKey(key) {
+  return key.slice(BIOMETRIC_WEB_PREFIX.length);
+}
 function getScopedListeners(scope) {
   return webScopeListeners.get(scope);
 }
@@ -147,25 +178,61 @@ const WebStorage = {
   dispose: () => {},
   set: (key, value, scope) => {
     const storage = getBrowserStorage(scope);
-    storage?.setItem(key, value);
+    if (!storage) {
+      return;
+    }
+    const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
+    storage.setItem(storageKey, value);
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
       notifyKeyListeners(getScopedListeners(scope), key);
     }
   },
   get: (key, scope) => {
     const storage = getBrowserStorage(scope);
-    return storage?.getItem(key) ?? undefined;
+    const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
+    return storage?.getItem(storageKey) ?? undefined;
   },
   remove: (key, scope) => {
     const storage = getBrowserStorage(scope);
-    storage?.removeItem(key);
+    if (!storage) {
+      return;
+    }
+    if (scope === _Storage.StorageScope.Secure) {
+      storage.removeItem(toSecureStorageKey(key));
+      storage.removeItem(toBiometricStorageKey(key));
+    } else {
+      storage.removeItem(key);
+    }
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
       notifyKeyListeners(getScopedListeners(scope), key);
     }
   },
   clear: scope => {
     const storage = getBrowserStorage(scope);
-    storage?.clear();
+    if (!storage) {
+      return;
+    }
+    if (scope === _Storage.StorageScope.Secure) {
+      const keysToRemove = [];
+      for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (key?.startsWith(SECURE_WEB_PREFIX) || key?.startsWith(BIOMETRIC_WEB_PREFIX)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach(key => storage.removeItem(key));
+    } else if (scope === _Storage.StorageScope.Disk) {
+      const keysToRemove = [];
+      for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (key && !key.startsWith(SECURE_WEB_PREFIX) && !key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach(key => storage.removeItem(key));
+    } else {
+      storage.clear();
+    }
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
       notifyAllListeners(getScopedListeners(scope));
     }
@@ -176,7 +243,8 @@ const WebStorage = {
       return;
     }
     keys.forEach((key, index) => {
-      storage.setItem(key, values[index]);
+      const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
+      storage.setItem(storageKey, values[index]);
     });
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
       const listeners = getScopedListeners(scope);
@@ -185,23 +253,88 @@ const WebStorage = {
   },
   getBatch: (keys, scope) => {
     const storage = getBrowserStorage(scope);
-    return keys.map(key => storage?.getItem(key) ?? undefined);
+    return keys.map(key => {
+      const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
+      return storage?.getItem(storageKey) ?? undefined;
+    });
   },
   removeBatch: (keys, scope) => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) {
-      return;
-    }
     keys.forEach(key => {
-      storage.removeItem(key);
+      WebStorage.remove(key, scope);
     });
-    if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
-      const listeners = getScopedListeners(scope);
-      keys.forEach(key => notifyKeyListeners(listeners, key));
-    }
   },
   addOnChange: (_scope, _callback) => {
     return () => {};
+  },
+  has: (key, scope) => {
+    const storage = getBrowserStorage(scope);
+    if (scope === _Storage.StorageScope.Secure) {
+      return storage?.getItem(toSecureStorageKey(key)) !== null || storage?.getItem(toBiometricStorageKey(key)) !== null;
+    }
+    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 === _Storage.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);
+    }
+    return Array.from(keys);
+  },
+  size: scope => {
+    return WebStorage.getAllKeys(scope).length;
+  },
+  setSecureAccessControl: () => {},
+  setKeychainAccessGroup: () => {},
+  setSecureBiometric: (key, value) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__ && !hasWarnedAboutWebBiometricFallback) {
+      hasWarnedAboutWebBiometricFallback = true;
+      console.warn("[NitroStorage] Biometric storage is not supported on web. Using localStorage.");
+    }
+    globalThis.localStorage?.setItem(toBiometricStorageKey(key), value);
+    notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), key);
+  },
+  getSecureBiometric: key => {
+    return globalThis.localStorage?.getItem(toBiometricStorageKey(key)) ?? undefined;
+  },
+  deleteSecureBiometric: key => {
+    globalThis.localStorage?.removeItem(toBiometricStorageKey(key));
+    notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), key);
+  },
+  hasSecureBiometric: key => {
+    return globalThis.localStorage?.getItem(toBiometricStorageKey(key)) !== null;
+  },
+  clearSecureBiometric: () => {
+    const storage = globalThis.localStorage;
+    if (!storage) return;
+    const keysToNotify = [];
+    const toRemove = [];
+    for (let i = 0; i < storage.length; i++) {
+      const k = storage.key(i);
+      if (k?.startsWith(BIOMETRIC_WEB_PREFIX)) {
+        toRemove.push(k);
+        keysToNotify.push(fromBiometricStorageKey(k));
+      }
+    }
+    toRemove.forEach(k => storage.removeItem(k));
+    const listeners = getScopedListeners(_Storage.StorageScope.Secure);
+    keysToNotify.forEach(key => notifyKeyListeners(listeners, key));
   }
 };
 function getRawValue(key, scope) {
@@ -267,15 +400,78 @@ const storage = exports.storage = {
     }
     clearScopeRawCache(scope);
     WebStorage.clear(scope);
+    if (scope === _Storage.StorageScope.Secure) {
+      WebStorage.clearSecureBiometric();
+    }
   },
   clearAll: () => {
     storage.clear(_Storage.StorageScope.Memory);
     storage.clear(_Storage.StorageScope.Disk);
     storage.clear(_Storage.StorageScope.Secure);
-  }
+  },
+  clearNamespace: (namespace, scope) => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope === _Storage.StorageScope.Memory) {
+      for (const key of memoryStore.keys()) {
+        if ((0, _internal.isNamespaced)(key, namespace)) {
+          memoryStore.delete(key);
+        }
+      }
+      notifyAllListeners(memoryListeners);
+      return;
+    }
+    if (scope === _Storage.StorageScope.Secure) {
+      flushSecureWrites();
+    }
+    const keys = WebStorage.getAllKeys(scope);
+    const namespacedKeys = keys.filter(k => (0, _internal.isNamespaced)(k, namespace));
+    if (namespacedKeys.length > 0) {
+      WebStorage.removeBatch(namespacedKeys, scope);
+      namespacedKeys.forEach(k => cacheRawValue(scope, k, undefined));
+      if (scope === _Storage.StorageScope.Secure) {
+        namespacedKeys.forEach(k => clearPendingSecureWrite(k));
+      }
+    }
+  },
+  clearBiometric: () => {
+    WebStorage.clearSecureBiometric();
+  },
+  has: (key, scope) => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope === _Storage.StorageScope.Memory) return memoryStore.has(key);
+    return WebStorage.has(key, scope);
+  },
+  getAllKeys: scope => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope === _Storage.StorageScope.Memory) return Array.from(memoryStore.keys());
+    return WebStorage.getAllKeys(scope);
+  },
+  getAll: scope => {
+    (0, _internal.assertValidScope)(scope);
+    const result = {};
+    if (scope === _Storage.StorageScope.Memory) {
+      memoryStore.forEach((value, key) => {
+        if (typeof value === "string") result[key] = value;
+      });
+      return result;
+    }
+    const keys = WebStorage.getAllKeys(scope);
+    keys.forEach(key => {
+      const val = WebStorage.get(key, scope);
+      if (val !== undefined) result[key] = val;
+    });
+    return result;
+  },
+  size: scope => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope === _Storage.StorageScope.Memory) return memoryStore.size;
+    return WebStorage.size(scope);
+  },
+  setAccessControl: _level => {},
+  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 defaultSerialize(value) {
   return (0, _internal.serializeWithPrimitiveFastPath)(value);
@@ -284,16 +480,20 @@ function defaultDeserialize(value) {
   return (0, _internal.deserializeWithPrimitiveFastPath)(value);
 }
 function createStorageItem(config) {
+  const storageKey = (0, _internal.prefixKey)(config.namespace, config.key);
   const serialize = config.serialize ?? defaultSerialize;
   const deserialize = config.deserialize ?? defaultDeserialize;
   const isMemory = config.scope === _Storage.StorageScope.Memory;
+  const isBiometric = config.biometric === true && config.scope === _Storage.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 === _Storage.StorageScope.Secure && config.coalesceSecureWrites === true;
+  const coalesceSecureWrites = config.scope === _Storage.StorageScope.Secure && config.coalesceSecureWrites === true && !isBiometric && secureAccessControl === undefined;
   const nonMemoryScope = config.scope === _Storage.StorageScope.Disk ? _Storage.StorageScope.Disk : config.scope === _Storage.StorageScope.Secure ? _Storage.StorageScope.Secure : null;
   if (expiration && expiration.ttlMs <= 0) {
     throw new Error("expiration.ttlMs must be greater than 0.");
@@ -317,65 +517,77 @@ function createStorageItem(config) {
       listeners.forEach(callback => callback());
     };
     if (isMemory) {
-      unsubscribe = addKeyListener(memoryListeners, config.key, listener);
+      unsubscribe = addKeyListener(memoryListeners, storageKey, listener);
       return;
     }
-    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 === _Storage.StorageScope.Secure && hasPendingSecureWrite(config.key)) {
-      return readPendingSecureWrite(config.key);
+    if (nonMemoryScope === _Storage.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 = WebStorage.get(config.key, config.scope);
-    cacheRawValue(nonMemoryScope, config.key, raw);
+    if (isBiometric) {
+      return WebStorage.getSecureBiometric(storageKey);
+    }
+    const raw = WebStorage.get(storageKey, config.scope);
+    cacheRawValue(nonMemoryScope, storageKey, raw);
     return raw;
   };
   const writeStoredRaw = rawValue => {
-    cacheRawValue(nonMemoryScope, config.key, rawValue);
+    if (isBiometric) {
+      WebStorage.setSecureBiometric(storageKey, rawValue);
+      return;
+    }
+    cacheRawValue(nonMemoryScope, storageKey, rawValue);
     if (coalesceSecureWrites) {
-      scheduleSecureWrite(config.key, rawValue);
+      scheduleSecureWrite(storageKey, rawValue);
       return;
     }
     if (nonMemoryScope === _Storage.StorageScope.Secure) {
-      clearPendingSecureWrite(config.key);
+      clearPendingSecureWrite(storageKey);
     }
-    WebStorage.set(config.key, rawValue, config.scope);
+    WebStorage.set(storageKey, rawValue, config.scope);
   };
   const removeStoredRaw = () => {
-    cacheRawValue(nonMemoryScope, config.key, undefined);
+    if (isBiometric) {
+      WebStorage.deleteSecureBiometric(storageKey);
+      return;
+    }
+    cacheRawValue(nonMemoryScope, storageKey, undefined);
     if (coalesceSecureWrites) {
-      scheduleSecureWrite(config.key, undefined);
+      scheduleSecureWrite(storageKey, undefined);
       return;
     }
     if (nonMemoryScope === _Storage.StorageScope.Secure) {
-      clearPendingSecureWrite(config.key);
+      clearPendingSecureWrite(storageKey);
     }
-    WebStorage.remove(config.key, config.scope);
+    WebStorage.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);
@@ -434,6 +646,7 @@ function createStorageItem(config) {
           if (parsed.expiresAt <= Date.now()) {
             removeStoredRaw();
             invalidateParsedCache();
+            onExpired?.(storageKey);
             lastValue = ensureValidatedValue(config.defaultValue, false);
             hasLastValue = true;
             return lastValue;
@@ -453,7 +666,7 @@ function createStorageItem(config) {
     const newValue = typeof valueOrFn === "function" ? valueOrFn(currentValue) : valueOrFn;
     invalidateParsedCache();
     if (validate && !validate(newValue)) {
-      throw new Error(`Validation failed for key "${config.key}" in scope "${_Storage.StorageScope[config.scope]}".`);
+      throw new Error(`Validation failed for key "${storageKey}" in scope "${_Storage.StorageScope[config.scope]}".`);
     }
     writeValueWithoutValidation(newValue);
   };
@@ -461,14 +674,19 @@ 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 WebStorage.hasSecureBiometric(storageKey);
+    return WebStorage.has(storageKey, config.scope);
+  };
   const subscribe = callback => {
     ensureSubscription();
     listeners.add(callback);
@@ -484,6 +702,7 @@ function createStorageItem(config) {
     get,
     set,
     delete: deleteItem,
+    has: hasItem,
     subscribe,
     serialize,
     deserialize,
@@ -494,8 +713,10 @@ function createStorageItem(config) {
     _hasValidation: validate !== undefined,
     _hasExpiration: expiration !== undefined,
     _readCacheEnabled: readCache,
+    _isBiometric: isBiometric,
+    _secureAccessControl: secureAccessControl,
     scope: config.scope,
-    key: config.key
+    key: storageKey
   };
   return storageItem;
 }
@@ -582,7 +803,7 @@ function setBatch(items, scope) {
   }
   const useRawBatchPath = items.every(({
     item
-  }) => canUseRawBatchPath(item));
+  }) => canUseRawBatchPath(asInternal(item)));
   if (!useRawBatchPath) {
     items.forEach(({
       item,
@@ -693,4 +914,23 @@ function runTransaction(scope, transaction) {
     throw error;
   }
 }
+function createSecureAuthStorage(config, options) {
+  const ns = options?.namespace ?? "auth";
+  const result = {};
+  for (const key of Object.keys(config)) {
+    const itemConfig = config[key];
+    result[key] = createStorageItem({
+      key,
+      scope: _Storage.StorageScope.Secure,
+      defaultValue: "",
+      namespace: ns,
+      biometric: itemConfig.biometric,
+      accessControl: itemConfig.accessControl,
+      expiration: itemConfig.ttlMs ? {
+        ttlMs: itemConfig.ttlMs
+      } : undefined
+    });
+  }
+  return result;
+}
 //# sourceMappingURL=index.web.js.map