react-native-nitro-storage 0.13.0 → 0.15.0

package/lib/module/storage-core.js

@@ -5,8 +5,19 @@ import { createMetricsRegistry } from "./core/metrics";
 import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, toVersionToken, assertValidStorageKey, prefixKey, isNamespaced, escapeCollidingRawValue, unescapeCollidingRawValue } from "./internal";
 import { assertAccessControlLevel, assertBiometricLevel, canUseRawBatchPath, canUseSecureRawBatchPath, createStorageCompositeError, createKeyChange, defaultDeserialize, defaultSerialize, isKeychainLockedError, isUpdater, normalizeStorageError, notifyAllListeners, notifyKeyListeners, redactSecureKeyChange, typedKeys } from "./shared";
 import { StorageEventRegistry } from "./storage-events";
-import { isStorageError } from "./storage-runtime";
+import { getStorageErrorCode, isStorageError } from "./storage-runtime";
 import { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
+function assertSynchronousCallbackResult(value, callbackKind) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return;
+  }
+  const then = value.then;
+  if (typeof then !== "function") {
+    return;
+  }
+  void Promise.resolve(value).catch(() => undefined);
+  throw new TypeError(`${callbackKind} callbacks must be synchronous and cannot return a Promise or thenable.`);
+}
 const EMPTY_KEYS = Object.freeze([]);
 function asInternal(item) {
   return item;
@@ -802,6 +813,10 @@ export function createStorageCore(buildAdapter) {
         flushSecureWrites();
       });
     },
+    /** Observes scheduled flush failures; explicit flush calls still throw. */
+    setScheduledFlushErrorObserver: observer => {
+      durability.setScheduledFlushErrorObserver(observer);
+    },
     setMetricsObserver: observer => {
       metrics.setObserver(observer);
     },
@@ -2126,6 +2141,84 @@ export function createStorageCore(buildAdapter) {
     }
     registeredMigrations.set(version, migration);
   }
+  function migrateSecureAccessControl(level, options) {
+    return measureOperation("storage:migrateSecureAccessControl", StorageScope.Secure, () => {
+      assertAccessControlLevel(level);
+      const requestedKeys = options?.keys;
+      requestedKeys?.forEach(key => {
+        assertValidStorageKey(key);
+      });
+      let keys;
+      try {
+        flushSecureWrites();
+        keys = Array.from(new Set(requestedKeys ?? adapter.backend.getAllKeys(StorageScope.Secure)));
+      } catch (error) {
+        if (getStorageErrorCode(error) !== "keychain_locked") {
+          throw error;
+        }
+        return {
+          migrated: [],
+          locked: [],
+          missing: [],
+          skipped: [],
+          failed: [],
+          enumerationLocked: true
+        };
+      }
+      secureDefaultAccessControl = level;
+      adapter.backend.setSecureAccessControl(level);
+      const result = {
+        migrated: [],
+        locked: [],
+        missing: [],
+        skipped: [],
+        failed: [],
+        enumerationLocked: false
+      };
+      if (!adapter.supportsSecureAccessControlMigration()) {
+        result.skipped = keys;
+        return result;
+      }
+      keys.forEach(key => {
+        try {
+          let hasBiometric;
+          try {
+            hasBiometric = adapter.backend.hasSecureBiometric(key);
+          } catch (error) {
+            if (getStorageErrorCode(error) !== "keychain_locked") {
+              throw error;
+            }
+            result.skipped.push(key);
+            return;
+          }
+          if (hasBiometric) {
+            result.skipped.push(key);
+            return;
+          }
+          const raw = adapter.backend.get(key, StorageScope.Secure);
+          if (raw === undefined) {
+            result.missing.push(key);
+            return;
+          }
+          adapter.backend.set(key, raw, StorageScope.Secure);
+          result.migrated.push(key);
+        } catch (error) {
+          const code = getStorageErrorCode(error);
+          if (code === "keychain_locked") {
+            result.locked.push(key);
+          } else {
+            result.failed.push(code === undefined ? {
+              key
+            } : {
+              key,
+              code
+            });
+          }
+        }
+      });
+      return result;
+    }, options?.keys?.length ?? 1);
+  }
   function migrateToLatest(scope = StorageScope.Disk) {
     return measureOperation("migration:run", scope, () => {
       assertValidScope(scope);
@@ -2138,7 +2231,8 @@ export function createStorageCore(buildAdapter) {
           return;
         }
         runTransaction(scope, tx => {
-          migration(tx);
+          const migrationResult = migration(tx);
+          assertSynchronousCallbackResult(migrationResult, "Migration");
           tx.setRaw(MIGRATION_VERSION_KEY, String(version));
         });
         appliedVersion = version;
@@ -2158,6 +2252,12 @@ export function createStorageCore(buildAdapter) {
       const NOT_SET = Symbol();
       const rollback = new Map();
       const itemRenameStates = new Map();
+      let transactionOpen = true;
+      const assertTransactionOpen = () => {
+        if (!transactionOpen) {
+          throw new TypeError("Transaction context is closed.");
+        }
+      };
       const rememberRollback = (key, item, includeOtherSecureRepresentation = false) => {
         const internal = item ? item : undefined;
         const representation = scope === StorageScope.Secure && internal?._isBiometric === true ? "biometric" : "plain";
@@ -2228,34 +2328,46 @@ export function createStorageCore(buildAdapter) {
       };
       const tx = {
         scope,
-        getRaw: key => getRawValue(key, scope),
+        getRaw: key => {
+          assertTransactionOpen();
+          return getRawValue(key, scope);
+        },
         setRaw: (key, value) => {
+          assertTransactionOpen();
           rememberRollback(key);
           setRawValue(key, value, scope);
         },
         removeRaw: key => {
+          assertTransactionOpen();
           rememberRollback(key, undefined, scope === StorageScope.Secure);
           removeRawValue(key, scope);
         },
         getItem: item => {
+          assertTransactionOpen();
           assertBatchScope([item], scope);
           rememberItemRollback(item);
           return item.get();
         },
         setItem: (item, value) => {
+          assertTransactionOpen();
           assertBatchScope([item], scope);
           rememberItemRollback(item);
           item.set(value);
         },
         removeItem: item => {
+          assertTransactionOpen();
           assertBatchScope([item], scope);
           rememberItemRollback(item);
           item.delete();
         }
       };
       try {
-        return transaction(tx);
+        const result = transaction(tx);
+        assertSynchronousCallbackResult(result, "Transaction");
+        transactionOpen = false;
+        return result;
       } catch (error) {
+        transactionOpen = false;
         itemRenameStates.forEach((migrated, item) => {
           item._setRenameMigrationState(migrated);
         });
@@ -2586,6 +2698,7 @@ export function createStorageCore(buildAdapter) {
     removeBatch,
     registerMigration,
     migrateToLatest,
+    migrateSecureAccessControl,
     runTransaction,
     createSecureAuthStorage,
     internals