react-native-nitro-storage 0.12.0 → 0.14.0

package/src/storage-core.ts

@@ -1,4 +1,7 @@
-import { createDurabilityCoordinator } from "./core/durability";
+import {
+  createDurabilityCoordinator,
+  type StorageScheduledFlushErrorObserver,
+} from "./core/durability";
 import { createMetricsRegistry } from "./core/metrics";
 import {
   MIGRATION_VERSION_KEY,
@@ -44,6 +47,7 @@ import {
   type StorageMetricsObserver,
   type StorageSelectorListener,
   type StorageSelectorSubscribeOptions,
+  type SynchronousCallbackResult,
   type StorageVersion,
   type Validator,
   type VersionedValue,
@@ -76,6 +80,28 @@ export type TransactionContext = {
   ) => void;
 };
 
+function assertSynchronousCallbackResult(
+  value: unknown,
+  callbackKind: "Transaction" | "Migration",
+): void {
+  if (
+    value === null ||
+    (typeof value !== "object" && typeof value !== "function")
+  ) {
+    return;
+  }
+
+  const then = (value as { then?: unknown }).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.`,
+  );
+}
+
 export type StorageItemConfig<T> = {
   key: string;
   scope: StorageScope;
@@ -318,7 +344,7 @@ function asInternal<T>(item: StorageItem<T>): StorageItemInternal<T> {
 export function createStorageCore(
   buildAdapter: (internals: StorageCoreInternals) => StorageCoreAdapter,
 ) {
-  const registeredMigrations = new Map<number, Migration>();
+  const registeredMigrations = new Map<number, Migration<unknown>>();
   const itemGroups = new Map<string, Set<StorageItemInternal<unknown>>>();
   const registeredKeyCounts = new Map<string, number>();
   const memoryStore = new Map<string, unknown>();
@@ -574,8 +600,9 @@ export function createStorageCore(
     operation: StorageChangeOperation,
     source: StorageChangeSource,
     changes: StorageKeyChangeEvent[],
+    emitWhenEmpty = false,
   ): void {
-    if (changes.length === 0) {
+    if (changes.length === 0 && !emitWhenEmpty) {
       return;
     }
 
@@ -1024,9 +1051,18 @@ export function createStorageCore(
         return;
       }
       measureOperation("storage:clear", scope, () => {
-        const previousValues = shouldReadPreviousEventValues(scope)
-          ? storage.getAll(scope)
-          : {};
+        let previousValues: Record<string, string> = {};
+        let previousValuesUnreadable = false;
+        if (shouldReadPreviousEventValues(scope)) {
+          try {
+            previousValues = storage.getAll(scope);
+          } catch (error) {
+            if (scope !== StorageScope.Disk) {
+              throw error;
+            }
+            previousValuesUnreadable = true;
+          }
+        }
         if (scope === StorageScope.Memory) {
           memoryStore.clear();
           memoryExpirationDeadlines.clear();
@@ -1049,9 +1085,15 @@ export function createStorageCore(
           return;
         }
 
+        let diskFlushFailed = false;
         if (scope === StorageScope.Disk) {
-          flushDiskWrites();
-          durability.clearAllPendingDiskWrites();
+          try {
+            flushDiskWrites();
+            durability.clearAllPendingDiskWrites();
+          } catch {
+            diskFlushFailed = true;
+            previousValuesUnreadable = shouldReadPreviousEventValues(scope);
+          }
         }
 
         if (scope === StorageScope.Secure) {
@@ -1061,6 +1103,9 @@ export function createStorageCore(
 
         clearScopeRawCache(scope);
         adapter.backend.clear(scope);
+        if (diskFlushFailed) {
+          durability.clearAllPendingDiskWrites();
+        }
         emitBatchChange(
           scope,
           "clear",
@@ -1075,6 +1120,7 @@ export function createStorageCore(
               adapter.changeSource,
             ),
           ),
+          previousValuesUnreadable,
         );
       });
     },
@@ -1465,6 +1511,12 @@ export function createStorageCore(
         flushSecureWrites();
       });
     },
+    /** Observes scheduled flush failures; explicit flush calls still throw. */
+    setScheduledFlushErrorObserver: (
+      observer?: StorageScheduledFlushErrorObserver,
+    ): void => {
+      durability.setScheduledFlushErrorObserver(observer);
+    },
     setMetricsObserver: (observer?: StorageMetricsObserver) => {
       metrics.setObserver(observer);
     },
@@ -3300,7 +3352,10 @@ export function createStorageCore(
     );
   }
 
-  function registerMigration(version: number, migration: Migration): void {
+  function registerMigration<TResult>(
+    version: number,
+    migration: Migration<TResult>,
+  ): void {
     if (!Number.isInteger(version) || version <= 0) {
       throw new Error("Migration version must be a positive integer.");
     }
@@ -3328,7 +3383,8 @@ export function createStorageCore(
           return;
         }
         runTransaction(scope, (tx) => {
-          migration(tx);
+          const migrationResult: unknown = migration(tx);
+          assertSynchronousCallbackResult(migrationResult, "Migration");
           tx.setRaw(MIGRATION_VERSION_KEY, String(version));
         });
         appliedVersion = version;
@@ -3340,7 +3396,7 @@ export function createStorageCore(
 
   function runTransaction<T>(
     scope: StorageScope,
-    transaction: (context: TransactionContext) => T,
+    transaction: (context: TransactionContext) => SynchronousCallbackResult<T>,
   ): T {
     return measureOperation("transaction:run", scope, () => {
       assertValidScope(scope);
@@ -3359,6 +3415,12 @@ export function createStorageCore(
       };
       const rollback = new Map<string, TransactionRollbackEntry>();
       const itemRenameStates = new Map<StorageItemInternal<unknown>, boolean>();
+      let transactionOpen = true;
+      const assertTransactionOpen = (): void => {
+        if (!transactionOpen) {
+          throw new TypeError("Transaction context is closed.");
+        }
+      };
 
       const rememberRollback = (
         key: string,
@@ -3466,26 +3528,34 @@ export function createStorageCore(
 
       const tx: TransactionContext = {
         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();
@@ -3493,8 +3563,12 @@ export function createStorageCore(
       };
 
       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);
         });

package/src/testing.ts

@@ -23,6 +23,10 @@ import type {
 
 export { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
 export { isKeychainLockedError } from "./shared";
+export type {
+  StorageScheduledFlushError,
+  StorageScheduledFlushErrorObserver,
+} from "./core/durability";
 export { migrateFromMMKV } from "./migration";
 export { getStorageErrorCode, isStorageError } from "./storage-runtime";
 export {
@@ -279,6 +283,7 @@ function buildTestingModule() {
 
   const reset = (): void => {
     storage.setEventObserver(undefined);
+    storage.setScheduledFlushErrorObserver(undefined);
     storage.setMetricsObserver(undefined);
     storage.resetMetrics();
     storage.clearAll();