react-native-nitro-storage 0.5.0 → 0.5.2

package/src/indexeddb-backend.ts

@@ -72,6 +72,7 @@ export async function createIndexedDBBackend(
   const db = await openDB(dbName, storeName);
   const cache = new Map<string, string>();
   const pendingWrites = new Set<Promise<void>>();
+  const pendingErrors: Error[] = [];
   const subscribers = new Set<(event: WebStorageChangeEvent) => void>();
   const sourceId = `nitro-storage-${Math.random().toString(36).slice(2)}`;
   const channelName =
@@ -92,6 +93,7 @@ export async function createIndexedDBBackend(
       error instanceof Error
         ? error
         : new Error(String(error ?? "Unknown IndexedDB error"));
+    pendingErrors.push(normalized);
     options.onError?.(normalized);
   }
 
@@ -277,6 +279,12 @@ export async function createIndexedDBBackend(
     },
     async flush(): Promise<void> {
       await Promise.all(Array.from(pendingWrites));
+      if (pendingErrors.length === 0) {
+        return;
+      }
+
+      const [error] = pendingErrors.splice(0);
+      throw error;
     },
   };
 

package/src/storage-events.ts

@@ -0,0 +1,184 @@
+import { StorageScope } from "./Storage.types";
+
+export type StorageChangeOperation =
+  | "set"
+  | "remove"
+  | "clear"
+  | "clearNamespace"
+  | "setBatch"
+  | "removeBatch"
+  | "import"
+  | "external";
+
+export type StorageChangeSource = "memory" | "native" | "web" | "external";
+
+export type StorageKeyChangeEvent = {
+  type: "key";
+  scope: StorageScope;
+  key: string;
+  oldValue: string | undefined;
+  newValue: string | undefined;
+  operation: StorageChangeOperation;
+  source: StorageChangeSource;
+};
+
+export type StorageBatchChangeEvent = {
+  type: "batch";
+  scope: StorageScope;
+  operation: StorageChangeOperation;
+  source: StorageChangeSource;
+  changes: StorageKeyChangeEvent[];
+};
+
+export type StorageChangeEvent =
+  | StorageKeyChangeEvent
+  | StorageBatchChangeEvent;
+
+export type StorageEventListener = (event: StorageChangeEvent) => void;
+
+type PrefixListener = {
+  prefix: string;
+  listener: StorageEventListener;
+};
+
+function addListener<T>(
+  registry: Map<StorageScope, Set<T>>,
+  scope: StorageScope,
+  listener: T,
+): () => void {
+  let listeners = registry.get(scope);
+  if (!listeners) {
+    listeners = new Set();
+    registry.set(scope, listeners);
+  }
+
+  listeners.add(listener);
+  return () => {
+    const scopedListeners = registry.get(scope);
+    if (!scopedListeners) {
+      return;
+    }
+    scopedListeners.delete(listener);
+    if (scopedListeners.size === 0) {
+      registry.delete(scope);
+    }
+  };
+}
+
+export class StorageEventRegistry {
+  private readonly scopeListeners = new Map<
+    StorageScope,
+    Set<StorageEventListener>
+  >();
+  private readonly keyListeners = new Map<
+    StorageScope,
+    Map<string, Set<StorageEventListener>>
+  >();
+  private readonly prefixListeners = new Map<
+    StorageScope,
+    Set<PrefixListener>
+  >();
+
+  subscribe(scope: StorageScope, listener: StorageEventListener): () => void {
+    return addListener(this.scopeListeners, scope, listener);
+  }
+
+  hasListeners(scope: StorageScope): boolean {
+    return (
+      (this.scopeListeners.get(scope)?.size ?? 0) > 0 ||
+      (this.keyListeners.get(scope)?.size ?? 0) > 0 ||
+      (this.prefixListeners.get(scope)?.size ?? 0) > 0
+    );
+  }
+
+  subscribeKey(
+    scope: StorageScope,
+    key: string,
+    listener: StorageEventListener,
+  ): () => void {
+    let scopedListeners = this.keyListeners.get(scope);
+    if (!scopedListeners) {
+      scopedListeners = new Map();
+      this.keyListeners.set(scope, scopedListeners);
+    }
+
+    let keyListeners = scopedListeners.get(key);
+    if (!keyListeners) {
+      keyListeners = new Set();
+      scopedListeners.set(key, keyListeners);
+    }
+
+    keyListeners.add(listener);
+    return () => {
+      const currentScopedListeners = this.keyListeners.get(scope);
+      const currentKeyListeners = currentScopedListeners?.get(key);
+      if (!currentKeyListeners) {
+        return;
+      }
+      currentKeyListeners.delete(listener);
+      if (currentKeyListeners.size === 0) {
+        currentScopedListeners?.delete(key);
+      }
+      if (currentScopedListeners?.size === 0) {
+        this.keyListeners.delete(scope);
+      }
+    };
+  }
+
+  subscribePrefix(
+    scope: StorageScope,
+    prefix: string,
+    listener: StorageEventListener,
+  ): () => void {
+    const entry: PrefixListener = { prefix, listener };
+    return addListener(this.prefixListeners, scope, entry);
+  }
+
+  emitKey(event: StorageKeyChangeEvent): void {
+    this.emitToScope(event);
+    this.emitToKey(event);
+    this.emitToPrefixes(event);
+  }
+
+  emitBatch(event: StorageBatchChangeEvent): void {
+    this.emitToScope(event);
+    event.changes.forEach((change) => {
+      this.emitToKey(change);
+    });
+    this.emitBatchToPrefixes(event);
+  }
+
+  private emitToScope(event: StorageChangeEvent): void {
+    this.scopeListeners.get(event.scope)?.forEach((listener) => {
+      listener(event);
+    });
+  }
+
+  private emitToKey(event: StorageKeyChangeEvent): void {
+    this.keyListeners
+      .get(event.scope)
+      ?.get(event.key)
+      ?.forEach((listener) => {
+        listener(event);
+      });
+  }
+
+  private emitToPrefixes(event: StorageKeyChangeEvent): void {
+    this.prefixListeners.get(event.scope)?.forEach(({ prefix, listener }) => {
+      if (event.key.startsWith(prefix)) {
+        listener(event);
+      }
+    });
+  }
+
+  private emitBatchToPrefixes(event: StorageBatchChangeEvent): void {
+    this.prefixListeners.get(event.scope)?.forEach(({ prefix, listener }) => {
+      const changes = event.changes.filter((change) =>
+        change.key.startsWith(prefix),
+      );
+      if (changes.length > 0) {
+        listener({ ...event, changes });
+      }
+    });
+  }
+}