@rozenite/storage-plugin 1.12.0 → 2.0.0

package/src/react-native/import.ts

@@ -1,28 +1,176 @@
 import type {
   StorageImportEntriesEvent,
+  StorageImportPreviewRequestEvent,
+  StorageImportPreviewResponseEvent,
+  StorageImportProgressEvent,
   StorageImportResultEvent,
-  StorageSetEntryEvent,
+  StorageInvalidatedEvent,
+  StorageRequestErrorEvent,
 } from '../shared/messaging';
+import { computePreview, parseSnapshot } from '../shared/snapshot';
+import {
+  supportsType,
+  type StorageEntry,
+  type StorageTarget,
+} from '../shared/types';
 import type { StorageView } from './storage-view';
 
 export type ImportEmittedEvent =
-  | StorageSetEntryEvent
-  | StorageImportResultEvent;
+  | StorageImportProgressEvent
+  | StorageImportResultEvent
+  | StorageInvalidatedEvent;
+
+type ImportPreviewResult =
+  | StorageImportPreviewResponseEvent
+  | StorageRequestErrorEvent;
+
+const isSameTarget = (left: StorageTarget, right: StorageTarget) =>
+  left.adapterId === right.adapterId && left.storageId === right.storageId;
+
+const isTarget = (value: unknown): value is StorageTarget =>
+  typeof value === 'object' &&
+  value != null &&
+  !Array.isArray(value) &&
+  typeof (value as { adapterId?: unknown }).adapterId === 'string' &&
+  (value as { adapterId: string }).adapterId.trim().length > 0 &&
+  typeof (value as { storageId?: unknown }).storageId === 'string' &&
+  (value as { storageId: string }).storageId.trim().length > 0;
+
+const getRequestId = (payload: unknown) =>
+  typeof payload === 'object' &&
+  payload != null &&
+  !Array.isArray(payload) &&
+  typeof (payload as { requestId?: unknown }).requestId === 'string'
+    ? (payload as { requestId: string }).requestId
+    : '';
+
+const isEntry = (value: unknown): value is StorageEntry => {
+  if (typeof value !== 'object' || value == null || Array.isArray(value)) {
+    return false;
+  }
+
+  const entry = value as { key?: unknown; type?: unknown; value?: unknown };
+  if (typeof entry.key !== 'string') return false;
+  if (entry.type === 'string') return typeof entry.value === 'string';
+  if (entry.type === 'number') return typeof entry.value === 'number';
+  if (entry.type === 'boolean') return typeof entry.value === 'boolean';
+  return (
+    entry.type === 'buffer' &&
+    Array.isArray(entry.value) &&
+    entry.value.every(
+      (byte) =>
+        typeof byte === 'number' &&
+        Number.isInteger(byte) &&
+        byte >= 0 &&
+        byte <= 255,
+    )
+  );
+};
+
+const isBlacklisted = (view: StorageView, key: string) => {
+  if (!view.blacklist) return false;
+  view.blacklist.lastIndex = 0;
+  return view.blacklist.test(key);
+};
+
+const findView = (views: readonly StorageView[], target: StorageTarget) =>
+  views.find((candidate) => isSameTarget(candidate.target, target));
+
+export const handleImportPreviewRequest = async (
+  views: readonly StorageView[],
+  payload: unknown,
+): Promise<ImportPreviewResult> => {
+  const requestId = getRequestId(payload);
+  const request = payload as Partial<StorageImportPreviewRequestEvent>;
+  const parsedSnapshot = parseSnapshot(request.snapshot);
+  if (
+    typeof request !== 'object' ||
+    request == null ||
+    request.type !== 'preview-import' ||
+    typeof request.requestId !== 'string' ||
+    request.requestId.trim().length === 0 ||
+    !isTarget(request.target) ||
+    !parsedSnapshot.ok
+  ) {
+    return {
+      type: 'storage-request-error',
+      requestId,
+      code: 'INVALID_REQUEST',
+      message:
+        'Import preview requests require a valid target, request ID, and snapshot.',
+    };
+  }
+
+  const view = findView(views, request.target);
+  if (!view) {
+    return {
+      type: 'storage-request-error',
+      requestId,
+      code: 'TARGET_NOT_FOUND',
+      message: 'The requested storage target was not found.',
+    };
+  }
+
+  try {
+    const entryKeys = new Set(await view.getAllKeys());
+    return {
+      type: 'import-preview',
+      requestId,
+      target: view.target,
+      preview: computePreview(parsedSnapshot.snapshot, {
+        target: view.target,
+        capabilities: view.capabilities,
+        entryKeys,
+        isBlacklisted: (key) => isBlacklisted(view, key),
+      }),
+    };
+  } catch {
+    return {
+      type: 'storage-request-error',
+      requestId,
+      code: 'READ_FAILED',
+      message: 'Failed to inspect the requested storage for import.',
+    };
+  }
+};
 
 export const handleImportEntries = async (
   views: StorageView[],
-  event: StorageImportEntriesEvent,
+  payload: unknown,
   emit: (out: ImportEmittedEvent) => void,
 ): Promise<void> => {
-  const view = views.find(
-    (candidate) =>
-      candidate.target.adapterId === event.target.adapterId &&
-      candidate.target.storageId === event.target.storageId,
-  );
+  const requestId = getRequestId(payload);
+  const event = payload as Partial<StorageImportEntriesEvent>;
+  if (
+    typeof event !== 'object' ||
+    event == null ||
+    event.type !== 'import-entries' ||
+    typeof event.requestId !== 'string' ||
+    event.requestId.trim().length === 0 ||
+    !isTarget(event.target) ||
+    !Array.isArray(event.entries) ||
+    !event.entries.every(isEntry)
+  ) {
+    emit({
+      type: 'import-result',
+      requestId,
+      target: isTarget(event.target)
+        ? event.target
+        : { adapterId: '', storageId: '' },
+      ok: false,
+      written: 0,
+      total: 0,
+      error: 'Import requests require a valid target, request ID, and entries.',
+    });
+    return;
+  }
+
+  const view = findView(views, event.target);
 
   if (!view) {
     emit({
       type: 'import-result',
+      requestId: event.requestId,
       target: event.target,
       ok: false,
       written: 0,
@@ -32,18 +180,33 @@ export const handleImportEntries = async (
     return;
   }
 
-  for (let i = 0; i < event.entries.length; i++) {
-    const entry = event.entries[i];
+  // Recheck policy at apply time so a preview cannot bypass a changed target.
+  const entries = event.entries.filter(
+    (entry) =>
+      supportsType(view.capabilities, entry.type) &&
+      !isBlacklisted(view, entry.key),
+  );
+
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
 
     try {
       await view.set(entry);
     } catch (error) {
+      if (i > 0) {
+        emit({
+          type: 'storage-invalidated',
+          target: event.target,
+          operation: 'import',
+        });
+      }
       emit({
         type: 'import-result',
+        requestId: event.requestId,
         target: event.target,
         ok: false,
         written: i,
-        total: event.entries.length,
+        total: entries.length,
         failedKey: entry.key,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -51,17 +214,28 @@ export const handleImportEntries = async (
     }
 
     emit({
-      type: 'set-entry',
+      type: 'import-progress',
+      requestId: event.requestId,
+      target: event.target,
+      written: i + 1,
+      total: entries.length,
+    });
+  }
+
+  if (entries.length > 0) {
+    emit({
+      type: 'storage-invalidated',
       target: event.target,
-      entry,
+      operation: 'import',
     });
   }
 
   emit({
     type: 'import-result',
+    requestId: event.requestId,
     target: event.target,
     ok: true,
-    written: event.entries.length,
-    total: event.entries.length,
+    written: entries.length,
+    total: entries.length,
   });
 };

package/src/react-native/storage-discovery.ts

@@ -0,0 +1,96 @@
+import type {
+  StorageDiscoverStoragesRequestEvent,
+  StorageDiscoverStoragesResponseEvent,
+  StorageRequestErrorEvent,
+} from '../shared/messaging';
+import type { StorageDescriptor } from '../shared/types';
+import type { StorageView } from './storage-view';
+
+type DiscoveryResult =
+  | StorageDiscoverStoragesResponseEvent
+  | StorageRequestErrorEvent;
+
+const getRequestId = (payload: unknown) => {
+  if (
+    typeof payload === 'object' &&
+    payload != null &&
+    !Array.isArray(payload) &&
+    typeof (payload as { requestId?: unknown }).requestId === 'string'
+  ) {
+    return (payload as { requestId: string }).requestId;
+  }
+
+  return '';
+};
+
+const validateRequest = (
+  payload: unknown,
+): payload is StorageDiscoverStoragesRequestEvent =>
+  typeof payload === 'object' &&
+  payload != null &&
+  !Array.isArray(payload) &&
+  (payload as { type?: unknown }).type === 'discover-storages' &&
+  typeof (payload as { requestId?: unknown }).requestId === 'string' &&
+  (payload as { requestId: string }).requestId.trim().length > 0;
+
+const toDescriptor = async (view: StorageView): Promise<StorageDescriptor> => ({
+  target: view.target,
+  adapterName: view.adapterName,
+  storageName: view.storageName,
+  entryCount: (await view.getAllKeys()).length,
+  capabilities: view.capabilities,
+  supportsSubscriptions: view.supportsSubscriptions,
+});
+
+const hasDuplicateTargets = (views: readonly Pick<StorageView, 'target'>[]) => {
+  const targets = new Set<string>();
+
+  return views.some(({ target }) => {
+    const id = `${target.adapterId}:${target.storageId}`;
+
+    if (targets.has(id)) {
+      return true;
+    }
+
+    targets.add(id);
+    return false;
+  });
+};
+
+export const handleStorageDiscoveryRequest = async (
+  views: readonly StorageView[],
+  payload: unknown,
+): Promise<DiscoveryResult> => {
+  const requestId = getRequestId(payload);
+
+  if (!validateRequest(payload)) {
+    return {
+      type: 'storage-request-error',
+      requestId,
+      code: 'INVALID_REQUEST',
+      message: 'Storage discovery requires a non-empty request ID.',
+    };
+  }
+
+  try {
+    if (hasDuplicateTargets(views)) {
+      return {
+        type: 'storage-request-error',
+        requestId,
+        code: 'INVALID_REQUEST',
+        message: 'Configured storages must have unique targets.',
+      };
+    }
+
+    const storages = await Promise.all(views.map(toDescriptor));
+
+    return { type: 'storage-descriptors', requestId, storages };
+  } catch {
+    return {
+      type: 'storage-request-error',
+      requestId,
+      code: 'READ_FAILED',
+      message: 'Failed to discover configured storages.',
+    };
+  }
+};

package/src/react-native/storage-view.ts

@@ -12,27 +12,11 @@ import {
   type SyncStorage,
 } from '../shared/types';
 
-const POLLING_INTERVAL_MS = 1500;
-
-type StorageSnapshotMap = Map<string, StorageEntry>;
-
 type AsyncStorageLike = SyncStorage | AsyncStorage;
 
 const isAsyncStorage = (storage: AsyncStorageLike): storage is AsyncStorage =>
   storage.kind === 'async';
 
-const fingerprintEntry = (entry: StorageEntry) => {
-  if (entry.type === 'buffer') {
-    return `${entry.type}:${entry.value.join(',')}`;
-  }
-
-  return `${entry.type}:${String(entry.value)}`;
-};
-
-const toSnapshotMap = (entries: StorageEntry[]) => {
-  return new Map(entries.map((entry) => [entry.key, entry]));
-};
-
 const shouldFilterKey = (storage: StorageNode, key: string) => {
   if (storage.shouldFilterKey?.(key)) {
     return true;
@@ -94,83 +78,25 @@ const deleteEntry = async (storage: AsyncStorageLike, key: string) => {
   storage.delete(key);
 };
 
+const clearStorage = async (storage: AsyncStorageLike) => {
+  await storage.clear();
+};
+
 export type StorageView = {
   id: string;
   target: StorageTarget;
   adapterName: string;
   storageName: string;
   capabilities: StorageCapabilities;
+  supportsSubscriptions: boolean;
   blacklist?: RegExp;
   get: (key: string) => Promise<StorageEntry | undefined>;
   set: (entry: StorageEntry) => Promise<void>;
   delete: (key: string) => Promise<void>;
+  purge: () => Promise<void>;
   getAllKeys: () => Promise<readonly string[]>;
   getAllEntries: () => Promise<StorageEntry[]>;
-  watch: (callbacks: {
-    onSet: (entry: StorageEntry) => void;
-    onDelete: (key: string) => void;
-  }) => Promise<StorageSubscription>;
-};
-
-const buildSnapshotMap = async (
-  getAllEntries: () => Promise<StorageEntry[]>,
-): Promise<StorageSnapshotMap> => {
-  const entries = await getAllEntries();
-  return toSnapshotMap(entries);
-};
-
-const diffSnapshots = (
-  previous: StorageSnapshotMap,
-  next: StorageSnapshotMap,
-  handlers: {
-    onSet: (entry: StorageEntry) => void;
-    onDelete: (key: string) => void;
-  },
-) => {
-  next.forEach((nextEntry, key) => {
-    const previousEntry = previous.get(key);
-
-    if (!previousEntry) {
-      handlers.onSet(nextEntry);
-      return;
-    }
-
-    if (fingerprintEntry(previousEntry) !== fingerprintEntry(nextEntry)) {
-      handlers.onSet(nextEntry);
-    }
-  });
-
-  previous.forEach((_value, key) => {
-    if (!next.has(key)) {
-      handlers.onDelete(key);
-    }
-  });
-};
-
-const createPollingSubscription = async (
-  getAllEntries: () => Promise<StorageEntry[]>,
-  handlers: {
-    onSet: (entry: StorageEntry) => void;
-    onDelete: (key: string) => void;
-  },
-): Promise<StorageSubscription> => {
-  let previousSnapshot = await buildSnapshotMap(getAllEntries);
-
-  const interval = setInterval(async () => {
-    try {
-      const nextSnapshot = await buildSnapshotMap(getAllEntries);
-      diffSnapshots(previousSnapshot, nextSnapshot, handlers);
-      previousSnapshot = nextSnapshot;
-    } catch {
-      // Silently ignore polling errors and try again on next tick.
-    }
-  }, POLLING_INTERVAL_MS);
-
-  return {
-    remove: () => {
-      clearInterval(interval);
-    },
-  };
+  watch?: (onChange: (key: string) => void) => Promise<StorageSubscription>;
 };
 
 export const createStorageView = (
@@ -178,6 +104,9 @@ export const createStorageView = (
   storageNode: StorageNode,
 ): StorageView => {
   const storage = storageNode.storage;
+  const subscribe = storage.subscribe;
+  const locallyMutatingKeys = new Set<string>();
+  let isLocallyPurging = false;
   const target: StorageTarget = {
     adapterId: adapter.id,
     storageId: storageNode.id,
@@ -208,40 +137,53 @@ export const createStorageView = (
     adapterName: adapter.name,
     storageName: storageNode.name,
     capabilities: storageNode.capabilities,
+    supportsSubscriptions: subscribe != null,
     blacklist: storageNode.blacklist,
     get,
     set: async (entry) => {
       checkTypeSupport(storageNode.capabilities, entry.type, target);
-      await setEntry(storage, entry);
+      locallyMutatingKeys.add(entry.key);
+      try {
+        await setEntry(storage, entry);
+      } finally {
+        locallyMutatingKeys.delete(entry.key);
+      }
     },
     delete: async (key) => {
-      await deleteEntry(storage, key);
+      locallyMutatingKeys.add(key);
+      try {
+        await deleteEntry(storage, key);
+      } finally {
+        locallyMutatingKeys.delete(key);
+      }
+    },
+    purge: async () => {
+      isLocallyPurging = true;
+      try {
+        await clearStorage(storage);
+      } finally {
+        isLocallyPurging = false;
+      }
     },
     getAllKeys: async () => {
       const keys = await getAllKeys(storage);
       return keys.filter((key) => !shouldFilterKey(storageNode, key));
     },
     getAllEntries,
-    watch: async ({ onSet, onDelete }) => {
-      if (storage.subscribe) {
-        return storage.subscribe(async (key) => {
-          try {
-            const entry = await get(key);
-
-            if (!entry) {
-              onDelete(key);
-              return;
-            }
-
-            onSet(entry);
-          } catch {
-            // Ignore runtime callback errors; polling fallback is not needed when subscribe exists.
-          }
-        });
-      }
-
-      return createPollingSubscription(getAllEntries, { onSet, onDelete });
-    },
+    ...(subscribe
+      ? {
+          watch: async (onChange) =>
+            subscribe((key) => {
+              if (
+                !isLocallyPurging &&
+                !locallyMutatingKeys.has(key) &&
+                !shouldFilterKey(storageNode, key)
+              ) {
+                onChange(key);
+              }
+            }),
+        }
+      : {}),
   };
 };