react-native-nitro-storage 0.5.4 → 0.5.6

package/src/index.web.ts

@@ -54,6 +54,8 @@ export type {
   StorageKeyChangeEvent,
 } from "./storage-events";
 export type {
+  WebDiskStorageBackend,
+  WebSecureStorageBackend,
   WebStorageBackend,
   WebStorageChangeEvent,
   WebStorageScope,
@@ -75,6 +77,12 @@ export type StorageMetricsEvent = {
   keysCount: number;
 };
 export type StorageMetricsObserver = (event: StorageMetricsEvent) => void;
+export type StorageEventObserverOptions = {
+  redactSecureValues?: boolean;
+};
+export type StorageExportOptions = {
+  includeSecureValues?: boolean;
+};
 export type StorageMetricSummary = {
   count: number;
   totalDurationMs: number;
@@ -254,6 +262,7 @@ let hasWarnedAboutWebBiometricFallback = false;
 let hasWindowStorageEventSubscription = false;
 let metricsObserver: StorageMetricsObserver | undefined;
 let eventObserver: StorageEventListener | undefined;
+let eventObserverRedactSecureValues = true;
 const metricsCounters = new Map<
   string,
   { count: number; totalDurationMs: number; maxDurationMs: number }
@@ -552,6 +561,21 @@ function resetBackendChangeSubscription(scope: NonMemoryScope): void {
   externalSyncUnsubscribers.delete(scope);
 }
 
+function closeWebBackend(
+  scope: NonMemoryScope,
+  backend: WebStorageBackend | undefined,
+): void {
+  if (!backend?.close) {
+    return;
+  }
+
+  try {
+    backend.close();
+  } catch (error) {
+    throw createWebStorageError(scope, "close", error, backend);
+  }
+}
+
 function ensureExternalSyncSubscriptions(): void {
   if (
     !hasWindowStorageEventSubscription &&
@@ -675,6 +699,49 @@ function hasStorageChangeObservers(scope: StorageScope): boolean {
   return storageEvents.hasListeners(scope) || eventObserver !== undefined;
 }
 
+function shouldReadPreviousEventValues(scope: StorageScope): boolean {
+  if (storageEvents.hasListeners(scope)) {
+    return true;
+  }
+  if (!eventObserver) {
+    return false;
+  }
+  return scope !== StorageScope.Secure || !eventObserverRedactSecureValues;
+}
+
+const SECURE_EVENT_REDACTED_VALUE = "[secure]";
+
+function redactSecureKeyChange(
+  event: StorageKeyChangeEvent,
+): StorageKeyChangeEvent {
+  if (event.scope !== StorageScope.Secure) {
+    return event;
+  }
+
+  return {
+    ...event,
+    oldValue:
+      event.oldValue === undefined ? undefined : SECURE_EVENT_REDACTED_VALUE,
+    newValue:
+      event.newValue === undefined ? undefined : SECURE_EVENT_REDACTED_VALUE,
+  };
+}
+
+function eventForGlobalObserver(event: StorageChangeEvent): StorageChangeEvent {
+  if (!eventObserverRedactSecureValues || event.scope !== StorageScope.Secure) {
+    return event;
+  }
+
+  if (event.type === "key") {
+    return redactSecureKeyChange(event);
+  }
+
+  return {
+    ...event,
+    changes: event.changes.map(redactSecureKeyChange),
+  };
+}
+
 function emitKeyChange(
   scope: StorageScope,
   key: string,
@@ -692,7 +759,7 @@ function emitKeyChange(
     source,
   );
   storageEvents.emitKey(event);
-  eventObserver?.(event);
+  eventObserver?.(eventForGlobalObserver(event));
 }
 
 function emitBatchChange(
@@ -713,7 +780,7 @@ function emitBatchChange(
     changes,
   };
   storageEvents.emitBatch(event);
-  eventObserver?.(event);
+  eventObserver?.(eventForGlobalObserver(event));
 }
 
 function readPendingSecureWrite(key: string): string | undefined {
@@ -1293,15 +1360,19 @@ export const storage = {
   ): (() => void) => {
     return storage.subscribePrefix(scope, prefixKey(namespace, ""), listener);
   },
-  setEventObserver: (observer?: StorageEventListener) => {
+  setEventObserver: (
+    observer?: StorageEventListener,
+    options: StorageEventObserverOptions = {},
+  ) => {
     eventObserver = observer;
+    eventObserverRedactSecureValues = options.redactSecureValues !== false;
     if (observer) {
       ensureExternalSyncSubscriptions();
     }
   },
   clear: (scope: StorageScope) => {
     measureOperation("storage:clear", scope, () => {
-      const previousValues = hasStorageChangeObservers(scope)
+      const previousValues = shouldReadPreviousEventValues(scope)
         ? storage.getAll(scope)
         : {};
       if (scope === StorageScope.Memory) {
@@ -1405,7 +1476,7 @@ export const storage = {
       }
 
       const keyPrefix = prefixKey(namespace, "");
-      const previousValues = hasStorageChangeObservers(scope)
+      const previousValues = shouldReadPreviousEventValues(scope)
         ? storage.getByPrefix(keyPrefix, scope)
         : {};
       if (scope === StorageScope.Disk) {
@@ -1551,11 +1622,26 @@ export const storage = {
       return result;
     });
   },
-  export: (scope: StorageScope): Record<string, string> => {
+  export: (
+    scope: StorageScope,
+    options: StorageExportOptions = {},
+  ): Record<string, string> => {
+    if (scope === StorageScope.Secure && options.includeSecureValues !== true) {
+      throw new Error(
+        "NitroStorage: exporting Secure scope exposes raw secret values. Pass { includeSecureValues: true } or use exportSecureUnsafe().",
+      );
+    }
     return measureOperation("storage:export", scope, () =>
       storage.getAll(scope),
     );
   },
+  exportSecureUnsafe: (): Record<string, string> => {
+    return measureOperation(
+      "storage:exportSecureUnsafe",
+      StorageScope.Secure,
+      () => storage.getAll(StorageScope.Secure),
+    );
+  },
   size: (scope: StorageScope): number => {
     return measureOperation("storage:size", scope, () => {
       assertValidScope(scope);
@@ -1759,12 +1845,17 @@ export const storage = {
 export function setWebSecureStorageBackend(
   backend?: WebSecureStorageBackend,
 ): void {
+  const previousBackend = webSecureStorageBackend;
+  const nextBackend = backend ?? createDefaultSecureBackend();
   pendingSecureWrites.clear();
-  webSecureStorageBackend = backend ?? createDefaultSecureBackend();
   resetBackendChangeSubscription(StorageScope.Secure);
+  webSecureStorageBackend = nextBackend;
   hydratedWebScopeKeyIndex.delete(StorageScope.Secure);
   clearScopeRawCache(StorageScope.Secure);
   ensureExternalSyncSubscriptions();
+  if (previousBackend !== nextBackend) {
+    closeWebBackend(StorageScope.Secure, previousBackend);
+  }
 }
 
 export function getWebSecureStorageBackend():
@@ -1776,12 +1867,17 @@ export function getWebSecureStorageBackend():
 export function setWebDiskStorageBackend(
   backend?: WebDiskStorageBackend,
 ): void {
+  const previousBackend = webDiskStorageBackend;
+  const nextBackend = backend ?? createDefaultDiskBackend();
   pendingDiskWrites.clear();
-  webDiskStorageBackend = backend ?? createDefaultDiskBackend();
   resetBackendChangeSubscription(StorageScope.Disk);
+  webDiskStorageBackend = nextBackend;
   hydratedWebScopeKeyIndex.delete(StorageScope.Disk);
   clearScopeRawCache(StorageScope.Disk);
   ensureExternalSyncSubscriptions();
+  if (previousBackend !== nextBackend) {
+    closeWebBackend(StorageScope.Disk, previousBackend);
+  }
 }
 
 export function getWebDiskStorageBackend(): WebDiskStorageBackend | undefined {
@@ -2597,7 +2693,7 @@ export function setBatch<T>(
 
         flushSecureWrites();
         const keys = secureEntries.map(({ item }) => item.key);
-        const oldValues = hasStorageChangeObservers(scope)
+        const oldValues = shouldReadPreviousEventValues(scope)
           ? WebStorage.getBatch(keys, scope)
           : [];
         const groupedByAccessControl = new Map<
@@ -2654,7 +2750,7 @@ export function setBatch<T>(
 
       const keys = items.map((entry) => entry.item.key);
       const values = items.map((entry) => entry.item.serialize(entry.value));
-      const oldValues = hasStorageChangeObservers(scope)
+      const oldValues = shouldReadPreviousEventValues(scope)
         ? WebStorage.getBatch(keys, scope)
         : [];
       WebStorage.setBatch(keys, values, scope);
@@ -2712,7 +2808,7 @@ export function removeBatch(
       if (scope === StorageScope.Secure) {
         flushSecureWrites();
       }
-      const oldValues = hasStorageChangeObservers(scope)
+      const oldValues = shouldReadPreviousEventValues(scope)
         ? WebStorage.getBatch(keys, scope)
         : [];
       WebStorage.removeBatch(keys, scope);

package/src/indexeddb-backend.ts

@@ -74,6 +74,7 @@ export async function createIndexedDBBackend(
   const pendingWrites = new Set<Promise<void>>();
   const pendingErrors: Error[] = [];
   const subscribers = new Set<(event: WebStorageChangeEvent) => void>();
+  let closed = false;
   const sourceId = `nitro-storage-${Math.random().toString(36).slice(2)}`;
   const channelName =
     options.channelName ?? `nitro-storage:${dbName}:${storeName}`;
@@ -82,6 +83,12 @@ export async function createIndexedDBBackend(
       ? new BroadcastChannel(channelName)
       : null;
 
+  function assertOpen(): void {
+    if (closed) {
+      throw new Error(`IndexedDB backend "${dbName}/${storeName}" is closed.`);
+    }
+  }
+
   function emitExternal(event: WebStorageChangeEvent): void {
     subscribers.forEach((subscriber) => {
       subscriber(event);
@@ -98,6 +105,10 @@ export async function createIndexedDBBackend(
   }
 
   channel?.addEventListener("message", (event: MessageEvent) => {
+    if (closed) {
+      return;
+    }
+
     const data = event.data as
       | (WebStorageChangeEvent & { sourceId?: string })
       | undefined;
@@ -209,34 +220,41 @@ export async function createIndexedDBBackend(
   const backend: WebSecureStorageBackend = {
     name: `indexeddb:${dbName}/${storeName}`,
     getItem(key: string): string | null {
+      assertOpen();
       return cache.get(key) ?? null;
     },
 
     setItem(key: string, value: string): void {
+      assertOpen();
       cache.set(key, value);
       persistSet(key, value);
       publish({ key, newValue: value });
     },
 
     removeItem(key: string): void {
+      assertOpen();
       cache.delete(key);
       persistDelete(key);
       publish({ key, newValue: null });
     },
 
     clear(): void {
+      assertOpen();
       cache.clear();
       persistClear();
       publish({ key: null, newValue: null });
     },
 
     getAllKeys(): string[] {
+      assertOpen();
       return Array.from(cache.keys());
     },
     getMany(keys: string[]): (string | null)[] {
+      assertOpen();
       return keys.map((key) => cache.get(key) ?? null);
     },
     setMany(entries): void {
+      assertOpen();
       entries.forEach(([key, value]) => {
         cache.set(key, value);
       });
@@ -253,6 +271,7 @@ export async function createIndexedDBBackend(
       }
     },
     removeMany(keys: string[]): void {
+      assertOpen();
       keys.forEach((key) => {
         cache.delete(key);
       });
@@ -269,9 +288,11 @@ export async function createIndexedDBBackend(
       }
     },
     size(): number {
+      assertOpen();
       return cache.size;
     },
     subscribe(listener): () => void {
+      assertOpen();
       subscribers.add(listener);
       return () => {
         subscribers.delete(listener);
@@ -286,6 +307,15 @@ export async function createIndexedDBBackend(
       const [error] = pendingErrors.splice(0);
       throw error;
     },
+    close(): void {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      subscribers.clear();
+      channel?.close();
+      db.close();
+    },
   };
 
   return backend;

package/src/storage-hooks.ts

@@ -2,13 +2,13 @@ import { useRef, useSyncExternalStore } from "react";
 
 type HookStorageItem<T> = {
   get: () => T;
-  set: (value: T | ((prev: T) => T)) => void;
+  set: StorageSetter<T>;
   subscribe: (callback: () => void) => () => void;
 };
 
-export function useStorage<T>(
-  item: HookStorageItem<T>,
-): [T, (value: T | ((prev: T) => T)) => void] {
+export type StorageSetter<T> = (value: T | ((prev: T) => T)) => void;
+
+export function useStorage<T>(item: HookStorageItem<T>): [T, StorageSetter<T>] {
   const value = useSyncExternalStore(item.subscribe, item.get, item.get);
   return [value, item.set];
 }
@@ -17,7 +17,7 @@ export function useStorageSelector<T, TSelected>(
   item: HookStorageItem<T>,
   selector: (value: T) => TSelected,
   isEqual: (prev: TSelected, next: TSelected) => boolean = Object.is,
-): [TSelected, (value: T | ((prev: T) => T)) => void] {
+): [TSelected, StorageSetter<T>] {
   const selectedRef = useRef<
     { hasValue: false } | { hasValue: true; value: TSelected }
   >({
@@ -43,6 +43,6 @@ export function useStorageSelector<T, TSelected>(
   return [selectedValue, item.set];
 }
 
-export function useSetStorage<T>(item: HookStorageItem<T>) {
+export function useSetStorage<T>(item: HookStorageItem<T>): StorageSetter<T> {
   return item.set;
 }

package/src/web-storage-backend.ts

@@ -21,6 +21,7 @@ export type WebStorageBackend = {
   size?: () => number;
   subscribe?: (listener: (event: WebStorageChangeEvent) => void) => () => void;
   flush?: () => Promise<void>;
+  close?: () => void;
   name?: string;
 };