react-native-nitro-storage 0.4.4 → 0.5.0

package/lib/commonjs/web-storage-backend.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLocalStorageWebBackend = createLocalStorageWebBackend;
+function getResolvedStorage(resolveStorage) {
+  if (resolveStorage) {
+    return resolveStorage();
+  }
+  if (typeof globalThis.localStorage === "undefined") {
+    return undefined;
+  }
+  return globalThis.localStorage;
+}
+function createLocalStorageWebBackend(options = {}) {
+  const includeKey = options.includeKey;
+  const resolveStorage = options.resolveStorage;
+  const listKeys = () => {
+    const storage = getResolvedStorage(resolveStorage);
+    if (!storage) {
+      return [];
+    }
+    const keys = [];
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (!key) {
+        continue;
+      }
+      if (includeKey && !includeKey(key)) {
+        continue;
+      }
+      keys.push(key);
+    }
+    return keys;
+  };
+  return {
+    name: options.name ?? "localStorage",
+    getItem(key) {
+      return getResolvedStorage(resolveStorage)?.getItem(key) ?? null;
+    },
+    setItem(key, value) {
+      getResolvedStorage(resolveStorage)?.setItem(key, value);
+    },
+    removeItem(key) {
+      getResolvedStorage(resolveStorage)?.removeItem(key);
+    },
+    clear() {
+      const storage = getResolvedStorage(resolveStorage);
+      if (!storage) {
+        return;
+      }
+      listKeys().forEach(key => {
+        storage.removeItem(key);
+      });
+    },
+    getAllKeys() {
+      return listKeys();
+    },
+    getMany(keys) {
+      const storage = getResolvedStorage(resolveStorage);
+      if (!storage) {
+        return keys.map(() => null);
+      }
+      return keys.map(key => storage.getItem(key));
+    },
+    setMany(entries) {
+      const storage = getResolvedStorage(resolveStorage);
+      if (!storage) {
+        return;
+      }
+      entries.forEach(([key, value]) => {
+        storage.setItem(key, value);
+      });
+    },
+    removeMany(keys) {
+      const storage = getResolvedStorage(resolveStorage);
+      if (!storage) {
+        return;
+      }
+      keys.forEach(key => {
+        storage.removeItem(key);
+      });
+    },
+    size() {
+      return listKeys().length;
+    }
+  };
+}
+//# sourceMappingURL=web-storage-backend.js.map

package/lib/commonjs/web-storage-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getResolvedStorage","resolveStorage","globalThis","localStorage","undefined","createLocalStorageWebBackend","options","includeKey","listKeys","storage","keys","index","length","key","push","name","getItem","setItem","value","removeItem","clear","forEach","getAllKeys","getMany","map","setMany","entries","removeMany","size"],"sourceRoot":"../../src","sources":["web-storage-backend.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/index.js

@@ -3,8 +3,10 @@
 import { NitroModules } from "react-native-nitro-modules";
 import { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
 import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, decodeNativeBatchValue, serializeWithPrimitiveFastPath, deserializeWithPrimitiveFastPath, toVersionToken, prefixKey, isNamespaced } from "./internal";
+import { getStorageErrorCode, isLockedStorageErrorCode } from "./storage-runtime";
 export { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
 export { migrateFromMMKV } from "./migration";
+export { getStorageErrorCode } from "./storage-runtime";
 function asInternal(item) {
   return item;
 }
@@ -18,6 +20,7 @@ const registeredMigrations = new Map();
 const runMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : task => {
   Promise.resolve().then(task);
 };
+const now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
 let _storageModule = null;
 function getStorageModule() {
   if (!_storageModule) {
@@ -30,11 +33,15 @@ const memoryListeners = new Map();
 const scopedListeners = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
 const scopedUnsubscribers = new Map();
 const scopedRawCache = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
+const pendingDiskWrites = new Map();
+let diskFlushScheduled = false;
+let diskWritesAsync = false;
 const pendingSecureWrites = new Map();
 let secureFlushScheduled = false;
 let secureDefaultAccessControl = AccessControl.WhenUnlocked;
 let metricsObserver;
 const metricsCounters = new Map();
+const nativeSecureBackend = "platform-secure-storage";
 function recordMetric(operation, scope, durationMs, keysCount = 1) {
   const existing = metricsCounters.get(operation);
   if (!existing) {
@@ -59,11 +66,11 @@ function measureOperation(operation, scope, fn, keysCount = 1) {
   if (!metricsObserver) {
     return fn();
   }
-  const start = Date.now();
+  const start = now();
   try {
     return fn();
   } finally {
-    recordMetric(operation, scope, Date.now() - start, keysCount);
+    recordMetric(operation, scope, now() - start, keysCount);
   }
 }
 function getScopedListeners(scope) {
@@ -120,12 +127,50 @@ function addKeyListener(registry, key, listener) {
 function readPendingSecureWrite(key) {
   return pendingSecureWrites.get(key)?.value;
 }
+function readPendingDiskWrite(key) {
+  return pendingDiskWrites.get(key)?.value;
+}
+function hasPendingDiskWrite(key) {
+  return pendingDiskWrites.has(key);
+}
 function hasPendingSecureWrite(key) {
   return pendingSecureWrites.has(key);
 }
+function clearPendingDiskWrite(key) {
+  pendingDiskWrites.delete(key);
+}
 function clearPendingSecureWrite(key) {
   pendingSecureWrites.delete(key);
 }
+function flushDiskWrites() {
+  diskFlushScheduled = false;
+  if (pendingDiskWrites.size === 0) {
+    return;
+  }
+  const writes = Array.from(pendingDiskWrites.values());
+  pendingDiskWrites.clear();
+  const keysToSet = [];
+  const valuesToSet = [];
+  const keysToRemove = [];
+  writes.forEach(({
+    key,
+    value
+  }) => {
+    if (value === undefined) {
+      keysToRemove.push(key);
+      return;
+    }
+    keysToSet.push(key);
+    valuesToSet.push(value);
+  });
+  const storageModule = getStorageModule();
+  if (keysToSet.length > 0) {
+    storageModule.setBatch(keysToSet, valuesToSet, StorageScope.Disk);
+  }
+  if (keysToRemove.length > 0) {
+    storageModule.removeBatch(keysToRemove, StorageScope.Disk);
+  }
+}
 function flushSecureWrites() {
   secureFlushScheduled = false;
   if (pendingSecureWrites.size === 0) {
@@ -165,6 +210,17 @@ function flushSecureWrites() {
     storageModule.removeBatch(keysToRemove, StorageScope.Secure);
   }
 }
+function scheduleDiskWrite(key, value) {
+  pendingDiskWrites.set(key, {
+    key,
+    value
+  });
+  if (diskFlushScheduled) {
+    return;
+  }
+  diskFlushScheduled = true;
+  runMicrotask(flushDiskWrites);
+}
 function scheduleSecureWrite(key, value, accessControl) {
   const pendingWrite = {
     key,
@@ -185,6 +241,13 @@ function ensureNativeScopeSubscription(scope) {
     return;
   }
   const unsubscribe = getStorageModule().addOnChange(scope, (key, value) => {
+    if (scope === StorageScope.Disk) {
+      if (key === "") {
+        pendingDiskWrites.clear();
+      } else {
+        clearPendingDiskWrite(key);
+      }
+    }
     if (scope === StorageScope.Secure) {
       if (key === "") {
         pendingSecureWrites.clear();
@@ -220,6 +283,9 @@ function getRawValue(key, scope) {
     const value = memoryStore.get(key);
     return typeof value === "string" ? value : undefined;
   }
+  if (scope === StorageScope.Disk && hasPendingDiskWrite(key)) {
+    return readPendingDiskWrite(key);
+  }
   if (scope === StorageScope.Secure && hasPendingSecureWrite(key)) {
     return readPendingSecureWrite(key);
   }
@@ -232,6 +298,15 @@ function setRawValue(key, value, scope) {
     notifyKeyListeners(memoryListeners, key);
     return;
   }
+  if (scope === StorageScope.Disk) {
+    cacheRawValue(scope, key, value);
+    if (diskWritesAsync) {
+      scheduleDiskWrite(key, value);
+      return;
+    }
+    flushDiskWrites();
+    clearPendingDiskWrite(key);
+  }
   if (scope === StorageScope.Secure) {
     flushSecureWrites();
     clearPendingSecureWrite(key);
@@ -247,6 +322,15 @@ function removeRawValue(key, scope) {
     notifyKeyListeners(memoryListeners, key);
     return;
   }
+  if (scope === StorageScope.Disk) {
+    cacheRawValue(scope, key, undefined);
+    if (diskWritesAsync) {
+      scheduleDiskWrite(key, undefined);
+      return;
+    }
+    flushDiskWrites();
+    clearPendingDiskWrite(key);
+  }
   if (scope === StorageScope.Secure) {
     flushSecureWrites();
     clearPendingSecureWrite(key);
@@ -273,6 +357,10 @@ export const storage = {
         notifyAllListeners(memoryListeners);
         return;
       }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+        pendingDiskWrites.clear();
+      }
       if (scope === StorageScope.Secure) {
         flushSecureWrites();
         pendingSecureWrites.clear();
@@ -301,6 +389,9 @@ export const storage = {
         return;
       }
       const keyPrefix = prefixKey(namespace, "");
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
       if (scope === StorageScope.Secure) {
         flushSecureWrites();
       }
@@ -324,6 +415,12 @@ export const storage = {
       if (scope === StorageScope.Memory) {
         return memoryStore.has(key);
       }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return getStorageModule().has(key, scope);
     });
   },
@@ -333,6 +430,12 @@ export const storage = {
       if (scope === StorageScope.Memory) {
         return Array.from(memoryStore.keys());
       }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return getStorageModule().getAllKeys(scope);
     });
   },
@@ -342,6 +445,12 @@ export const storage = {
       if (scope === StorageScope.Memory) {
         return Array.from(memoryStore.keys()).filter(key => key.startsWith(prefix));
       }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return getStorageModule().getKeysByPrefix(prefix, scope);
     });
   },
@@ -361,6 +470,12 @@ export const storage = {
         });
         return result;
       }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === StorageScope.Secure) {
+        flushSecureWrites();
+      }
       const values = getStorageModule().getBatch(keys, scope);
       keys.forEach((key, idx) => {
         const value = decodeNativeBatchValue(values[idx]);
@@ -381,6 +496,12 @@ export const storage = {
         });
         return result;
       }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === StorageScope.Secure) {
+        flushSecureWrites();
+      }
       const keys = getStorageModule().getAllKeys(scope);
       if (keys.length === 0) return result;
       const values = getStorageModule().getBatch(keys, scope);
@@ -397,6 +518,12 @@ export const storage = {
       if (scope === StorageScope.Memory) {
         return memoryStore.size;
       }
+      if (scope === StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return getStorageModule().size(scope);
     });
   },
@@ -411,6 +538,19 @@ export const storage = {
       getStorageModule().setSecureWritesAsync(enabled);
     });
   },
+  setDiskWritesAsync: enabled => {
+    measureOperation("storage:setDiskWritesAsync", StorageScope.Disk, () => {
+      diskWritesAsync = enabled;
+      if (!enabled) {
+        flushDiskWrites();
+      }
+    });
+  },
+  flushDiskWrites: () => {
+    measureOperation("storage:flushDiskWrites", StorageScope.Disk, () => {
+      flushDiskWrites();
+    });
+  },
   flushSecureWrites: () => {
     measureOperation("storage:flushSecureWrites", StorageScope.Secure, () => {
       flushSecureWrites();
@@ -439,6 +579,67 @@ export const storage = {
   resetMetrics: () => {
     metricsCounters.clear();
   },
+  getCapabilities: () => ({
+    platform: "native",
+    backend: {
+      disk: "platform-preferences",
+      secure: nativeSecureBackend
+    },
+    writeBuffering: {
+      disk: true,
+      secure: true
+    },
+    errorClassification: true
+  }),
+  getSecurityCapabilities: () => ({
+    platform: "native",
+    secureStorage: {
+      backend: nativeSecureBackend,
+      encrypted: "available",
+      accessControl: "unknown",
+      keychainAccessGroup: "unknown",
+      hardwareBacked: "unknown"
+    },
+    biometric: {
+      storage: "unknown",
+      prompt: "unknown",
+      biometryOnly: "unknown",
+      biometryOrPasscode: "unknown"
+    },
+    metadata: {
+      perKey: true,
+      listsWithoutValues: true,
+      persistsTimestamps: false
+    }
+  }),
+  getSecureMetadata: key => {
+    return measureOperation("storage:getSecureMetadata", StorageScope.Secure, () => {
+      flushSecureWrites();
+      const storageModule = getStorageModule();
+      const biometricProtected = storageModule.hasSecureBiometric(key);
+      const exists = biometricProtected || storageModule.has(key, StorageScope.Secure);
+      let kind = "missing";
+      if (exists) {
+        kind = biometricProtected ? "biometric" : "secure";
+      }
+      return {
+        key,
+        exists,
+        kind,
+        backend: nativeSecureBackend,
+        encrypted: "available",
+        hardwareBacked: "unknown",
+        biometricProtected,
+        valueExposed: false
+      };
+    });
+  },
+  getAllSecureMetadata: () => {
+    return measureOperation("storage:getAllSecureMetadata", StorageScope.Secure, () => {
+      flushSecureWrites();
+      return getStorageModule().getAllKeys(StorageScope.Secure).map(key => storage.getSecureMetadata(key));
+    });
+  },
   getString: (key, scope) => {
     return measureOperation("storage:getString", scope, () => {
       return getRawValue(key, scope);
@@ -482,6 +683,15 @@ export function setWebSecureStorageBackend(_backend) {
 export function getWebSecureStorageBackend() {
   return undefined;
 }
+export function setWebDiskStorageBackend(_backend) {
+  // Native platforms do not use web disk backends.
+}
+export function getWebDiskStorageBackend() {
+  return undefined;
+}
+export async function flushWebStorageBackends() {
+  // Native platforms do not use web storage backends.
+}
 function canUseRawBatchPath(item) {
   return item._hasExpiration === false && item._hasValidation === false && item._isBiometric !== true && item._secureAccessControl === undefined;
 }
@@ -509,6 +719,7 @@ export function createStorageItem(config) {
   const expirationTtlMs = expiration?.ttlMs;
   const memoryExpiration = expiration && isMemory ? new Map() : null;
   const readCache = !isMemory && config.readCache === true;
+  const coalesceDiskWrites = config.scope === StorageScope.Disk && config.coalesceDiskWrites === true;
   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;
@@ -556,6 +767,12 @@ export function createStorageItem(config) {
       }
       return memoryStore.get(storageKey);
     }
+    if (nonMemoryScope === StorageScope.Disk) {
+      const pending = pendingDiskWrites.get(storageKey);
+      if (pending !== undefined) {
+        return pending.value;
+      }
+    }
     if (nonMemoryScope === StorageScope.Secure && !isBiometric) {
       const pending = pendingSecureWrites.get(storageKey);
       if (pending !== undefined) {
@@ -582,6 +799,13 @@ export function createStorageItem(config) {
       return;
     }
     cacheRawValue(nonMemoryScope, storageKey, rawValue);
+    if (nonMemoryScope === StorageScope.Disk) {
+      if (coalesceDiskWrites || diskWritesAsync) {
+        scheduleDiskWrite(storageKey, rawValue);
+        return;
+      }
+      clearPendingDiskWrite(storageKey);
+    }
     if (coalesceSecureWrites) {
       scheduleSecureWrite(storageKey, rawValue, secureAccessControl ?? secureDefaultAccessControl);
       return;
@@ -598,6 +822,13 @@ export function createStorageItem(config) {
       return;
     }
     cacheRawValue(nonMemoryScope, storageKey, undefined);
+    if (nonMemoryScope === StorageScope.Disk) {
+      if (coalesceDiskWrites || diskWritesAsync) {
+        scheduleDiskWrite(storageKey, undefined);
+        return;
+      }
+      clearPendingDiskWrite(storageKey);
+    }
     if (coalesceSecureWrites) {
       scheduleSecureWrite(storageKey, undefined, secureAccessControl ?? secureDefaultAccessControl);
       return;
@@ -758,6 +989,18 @@ export function createStorageItem(config) {
   const hasItem = () => measureOperation("item:has", config.scope, () => {
     if (isMemory) return memoryStore.has(storageKey);
     if (isBiometric) return getStorageModule().hasSecureBiometric(storageKey);
+    if (nonMemoryScope === StorageScope.Disk) {
+      const pending = pendingDiskWrites.get(storageKey);
+      if (pending !== undefined) {
+        return pending.value !== undefined;
+      }
+    }
+    if (nonMemoryScope === StorageScope.Secure) {
+      const pending = pendingSecureWrites.get(storageKey);
+      if (pending !== undefined) {
+        return pending.value !== undefined;
+      }
+    }
     return getStorageModule().has(storageKey, config.scope);
   });
   const subscribe = callback => {
@@ -820,6 +1063,13 @@ export function getBatch(items, scope) {
     const keysToFetch = [];
     const keyIndexes = [];
     items.forEach((item, index) => {
+      if (scope === StorageScope.Disk) {
+        const pending = pendingDiskWrites.get(item.key);
+        if (pending !== undefined) {
+          rawValues[index] = pending.value;
+          return;
+        }
+      }
       if (scope === StorageScope.Secure) {
         const pending = pendingSecureWrites.get(item.key);
         if (pending !== undefined) {
@@ -938,6 +1188,7 @@ export function setBatch(items, scope) {
       });
       return;
     }
+    flushDiskWrites();
     const useRawBatchPath = items.every(({
       item
     }) => canUseRawBatchPath(asInternal(item)));
@@ -962,6 +1213,9 @@ export function removeBatch(items, scope) {
       return;
     }
     const keys = items.map(item => item.key);
+    if (scope === StorageScope.Disk) {
+      flushDiskWrites();
+    }
     if (scope === StorageScope.Secure) {
       flushSecureWrites();
     }
@@ -1007,6 +1261,9 @@ export function migrateToLatest(scope = StorageScope.Disk) {
 export function runTransaction(scope, transaction) {
   return measureOperation("transaction:run", scope, () => {
     assertValidScope(scope);
+    if (scope === StorageScope.Disk) {
+      flushDiskWrites();
+    }
     if (scope === StorageScope.Secure) {
       flushSecureWrites();
     }
@@ -1073,6 +1330,9 @@ export function runTransaction(scope, transaction) {
             valuesToSet.push(previousValue);
           }
         });
+        if (scope === StorageScope.Disk) {
+          flushDiskWrites();
+        }
         if (scope === StorageScope.Secure) {
           flushSecureWrites();
         }
@@ -1090,9 +1350,7 @@ export function runTransaction(scope, transaction) {
   });
 }
 export function isKeychainLockedError(err) {
-  if (!(err instanceof Error)) return false;
-  const msg = err.message;
-  return msg.includes("errSecInteractionNotAllowed") || msg.includes("UserNotAuthenticatedException") || msg.includes("KeyStoreException") || msg.includes("KeyPermanentlyInvalidatedException") || msg.includes("InvalidKeyException") || msg.includes("android.security.keystore");
+  return isLockedStorageErrorCode(getStorageErrorCode(err));
 }
 export function createSecureAuthStorage(config, options) {
   const ns = options?.namespace ?? "auth";