@rozenite/storage-plugin 1.8.0 → 1.9.0

package/dist/react-native/index.d.ts

@@ -24,13 +24,13 @@ export declare type AsyncStorageLike = {
     removeItem: (key: string) => Promise<void>;
 };
 
-export declare let createAsyncStorageAdapter: createAsyncStorageAdapter_2;
+export declare let createAsyncStorageAdapter: typeof createAsyncStorageAdapter_2;
 
 declare const createAsyncStorageAdapter_2: (options: CreateAsyncStorageAdapterOptions) => StorageAdapter;
 
 export declare type CreateAsyncStorageAdapterOptions = SingleStorageOptions | MultiStorageOptions;
 
-export declare let createExpoAsyncStorageAdapter: createExpoAsyncStorageAdapter_2;
+export declare let createExpoAsyncStorageAdapter: typeof createExpoAsyncStorageAdapter_2;
 
 /**
  * @deprecated Use createAsyncStorageAdapter instead.
@@ -39,7 +39,7 @@ declare const createExpoAsyncStorageAdapter_2: (options: CreateAsyncStorageAdapt
 
 export declare type CreateExpoAsyncStorageAdapterOptions = CreateAsyncStorageAdapterOptions;
 
-export declare let createExpoSecureStorageAdapter: createExpoSecureStorageAdapter_2;
+export declare let createExpoSecureStorageAdapter: typeof createExpoSecureStorageAdapter_2;
 
 declare const createExpoSecureStorageAdapter_2: ({ storage, keys, adapterId, adapterName, storageId, storageName, blacklist, }: CreateExpoSecureStorageAdapterOptions) => StorageAdapter;
 
@@ -53,7 +53,7 @@ export declare type CreateExpoSecureStorageAdapterOptions = {
     blacklist?: RegExp;
 };
 
-export declare let createMMKVStorageAdapter: createMMKVStorageAdapter_2;
+export declare let createMMKVStorageAdapter: typeof createMMKVStorageAdapter_2;
 
 declare const createMMKVStorageAdapter_2: ({ adapterId, adapterName, storages, blacklist, }: CreateMMKVStorageAdapterOptions) => StorageAdapter;
 
@@ -86,6 +86,11 @@ export declare type SecureStorageLike = {
     deleteItemAsync: (key: string) => Promise<void>;
 };
 
+declare type SerializedBlacklist = {
+    source: string;
+    flags: string;
+};
+
 declare type SingleStorageOptions = {
     storage: AsyncStorageLike;
     adapterId?: string;
@@ -133,7 +138,7 @@ export declare type StorageEntryType = StorageEntry['type'];
 
 export declare type StorageEntryValue = StorageEntry['value'];
 
-declare type StorageEvent_2 = StorageSnapshotEvent | StorageSetEntryEvent | StorageDeleteEntryEvent | StorageGetSnapshotEvent;
+declare type StorageEvent_2 = StorageSnapshotEvent | StorageSetEntryEvent | StorageDeleteEntryEvent | StorageGetSnapshotEvent | StorageImportEntriesEvent | StorageImportResultEvent;
 
 declare type StorageEventMap = {
     [K in StorageEvent_2['type']]: Extract<StorageEvent_2, {
@@ -146,12 +151,29 @@ declare type StorageGetSnapshotEvent = {
     target: StorageTarget | 'all';
 };
 
+declare type StorageImportEntriesEvent = {
+    type: 'import-entries';
+    target: StorageTarget;
+    entries: StorageEntry[];
+};
+
+declare type StorageImportResultEvent = {
+    type: 'import-result';
+    target: StorageTarget;
+    ok: boolean;
+    written: number;
+    total: number;
+    failedKey?: string;
+    error?: string;
+};
+
 export declare type StorageNode = {
     id: string;
     name: string;
     storage: SyncStorage | AsyncStorage;
     capabilities: StorageCapabilities;
     blacklist?: RegExp;
+    shouldFilterKey?: (key: string) => boolean;
 };
 
 declare type StorageSetEntryEvent = {
@@ -166,6 +188,7 @@ declare type StorageSnapshotEvent = {
     adapterName: string;
     storageName: string;
     capabilities: StorageCapabilities;
+    blacklist?: SerializedBlacklist;
     entries: StorageEntry[];
 };
 
@@ -187,7 +210,7 @@ export declare type SyncStorage = {
     subscribe?: (callback: (key: string) => void) => StorageSubscription;
 };
 
-export declare let useRozeniteStoragePlugin: useRozeniteStoragePlugin_2;
+export declare let useRozeniteStoragePlugin: typeof useRozeniteStoragePlugin_2;
 
 declare const useRozeniteStoragePlugin_2: ({ storages, }: RozeniteStoragePluginOptions) => RozeniteDevToolsClient<StorageEventMap> | null;
 

package/dist/rozenite.json

@@ -1 +1 @@
-{"name":"@rozenite/storage-plugin","version":"1.8.0","description":"Generic Storage Inspector for Rozenite.","panels":[{"name":"Storage","source":"/devtools/panel.html"}]}
+{"name":"@rozenite/storage-plugin","version":"1.9.0","description":"Generic Storage Inspector for Rozenite.","panels":[{"name":"Storage","source":"/devtools/panel.html"}]}

package/dist/sdk/index.d.ts

@@ -99,6 +99,7 @@ export declare type StorageNode = {
     storage: SyncStorage | AsyncStorage;
     capabilities: StorageCapabilities;
     blacklist?: RegExp;
+    shouldFilterKey?: (key: string) => boolean;
 };
 
 export declare type StorageReadEntryArgs = StorageSelection & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rozenite/storage-plugin",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Generic Storage Inspector for Rozenite.",
   "type": "module",
   "main": "./dist/react-native/index.cjs",
@@ -15,9 +15,9 @@
     "url": "https://github.com/callstackincubator/rozenite.git"
   },
   "dependencies": {
-    "@rozenite/agent-shared": "1.8.0",
-    "@rozenite/agent-bridge": "1.8.0",
-    "@rozenite/plugin-bridge": "1.8.0"
+    "@rozenite/plugin-bridge": "1.9.0",
+    "@rozenite/agent-shared": "1.9.0",
+    "@rozenite/agent-bridge": "1.9.0"
   },
   "devDependencies": {
     "@tanstack/react-table": "^8.21.3",
@@ -38,8 +38,8 @@
     "tailwindcss-animate": "^1.0.7",
     "typescript": "~5.9.3",
     "vite": "^7.3.1",
-    "@rozenite/vite-plugin": "1.8.0",
-    "rozenite": "1.8.0"
+    "@rozenite/vite-plugin": "1.9.0",
+    "rozenite": "1.9.0"
   },
   "peerDependencies": {
     "@react-native-async-storage/async-storage": "*",

package/src/react-native/__tests__/import.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it, vi } from 'vitest';
+import { handleImportEntries, type ImportEmittedEvent } from '../import';
+import type { StorageView } from '../storage-view';
+import { getStorageViewId } from '../../shared/types';
+import type { StorageEntry, StorageTarget } from '../../shared/types';
+import type { StorageImportEntriesEvent } from '../../shared/messaging';
+
+const target: StorageTarget = { adapterId: 'mmkv', storageId: 'user' };
+
+const buildView = (overrides?: Partial<StorageView>): StorageView => {
+  const unexpected = (method: string) =>
+    vi.fn(() => {
+      throw new Error(`Unexpected call to ${method}`);
+    });
+
+  return {
+    id: getStorageViewId(target),
+    target,
+    adapterName: 'MMKV',
+    storageName: 'user',
+    capabilities: {
+      supportedTypes: ['string', 'number', 'boolean', 'buffer'],
+    },
+    get: unexpected('get'),
+    set: vi.fn(async () => {}),
+    delete: unexpected('delete'),
+    getAllKeys: unexpected('getAllKeys'),
+    getAllEntries: unexpected('getAllEntries'),
+    watch: unexpected('watch'),
+    ...overrides,
+  };
+};
+
+const buildEntries = (count: number): StorageEntry[] =>
+  Array.from({ length: count }, (_, index) => ({
+    key: `k${index}`,
+    type: 'string' as const,
+    value: `v${index}`,
+  }));
+
+describe('handleImportEntries', () => {
+  it('emits a set-entry echo per write followed by a success import-result', async () => {
+    const view = buildView();
+    const entries = buildEntries(5);
+    const event: StorageImportEntriesEvent = {
+      type: 'import-entries',
+      target,
+      entries,
+    };
+    const emitted: ImportEmittedEvent[] = [];
+
+    await handleImportEntries([view], event, (out) => emitted.push(out));
+
+    expect(view.set).toHaveBeenCalledTimes(5);
+
+    expect(emitted).toHaveLength(6);
+    expect(emitted.slice(0, 5)).toEqual(
+      entries.map((entry) => ({
+        type: 'set-entry',
+        target,
+        entry,
+      })),
+    );
+    expect(emitted[5]).toEqual({
+      type: 'import-result',
+      target,
+      ok: true,
+      written: 5,
+      total: 5,
+    });
+  });
+
+  it('stops at the first write that throws and reports the failed key', async () => {
+    const failingKey = 'k2';
+    const view = buildView({
+      set: vi.fn(async (entry: StorageEntry) => {
+        if (entry.key === failingKey) {
+          throw new Error('boom');
+        }
+      }),
+    });
+    const entries = buildEntries(5);
+    const event: StorageImportEntriesEvent = {
+      type: 'import-entries',
+      target,
+      entries,
+    };
+    const emitted: ImportEmittedEvent[] = [];
+
+    await handleImportEntries([view], event, (out) => emitted.push(out));
+
+    // 2 set-entry echoes (k0, k1), then the failure result. No echoes for k2+.
+    expect(view.set).toHaveBeenCalledTimes(3);
+    expect(emitted).toHaveLength(3);
+    expect(emitted[0]).toMatchObject({ type: 'set-entry', entry: entries[0] });
+    expect(emitted[1]).toMatchObject({ type: 'set-entry', entry: entries[1] });
+    expect(emitted[2]).toEqual({
+      type: 'import-result',
+      target,
+      ok: false,
+      written: 2,
+      total: 5,
+      failedKey: failingKey,
+      error: 'boom',
+    });
+  });
+
+  it('coerces non-Error throws to a string error message', async () => {
+    const view = buildView({
+      set: vi.fn(async () => {
+        throw 'plain string failure';
+      }),
+    });
+    const event: StorageImportEntriesEvent = {
+      type: 'import-entries',
+      target,
+      entries: buildEntries(1),
+    };
+    const emitted: ImportEmittedEvent[] = [];
+
+    await handleImportEntries([view], event, (out) => emitted.push(out));
+
+    expect(emitted).toHaveLength(1);
+    expect(emitted[0]).toMatchObject({
+      type: 'import-result',
+      ok: false,
+      error: 'plain string failure',
+    });
+  });
+
+  it('emits an unknown-target import-result without calling set', async () => {
+    const view = buildView();
+    const unknownTarget: StorageTarget = {
+      adapterId: 'async-storage',
+      storageId: 'default',
+    };
+    const entries = buildEntries(3);
+    const event: StorageImportEntriesEvent = {
+      type: 'import-entries',
+      target: unknownTarget,
+      entries,
+    };
+    const emitted: ImportEmittedEvent[] = [];
+
+    await handleImportEntries([view], event, (out) => emitted.push(out));
+
+    expect(view.set).not.toHaveBeenCalled();
+    expect(emitted).toEqual([
+      {
+        type: 'import-result',
+        target: unknownTarget,
+        ok: false,
+        written: 0,
+        total: 3,
+        error: 'Target storage not found',
+      },
+    ]);
+  });
+
+  it('handles empty entries as a successful no-op', async () => {
+    const view = buildView();
+    const event: StorageImportEntriesEvent = {
+      type: 'import-entries',
+      target,
+      entries: [],
+    };
+    const emitted: ImportEmittedEvent[] = [];
+
+    await handleImportEntries([view], event, (out) => emitted.push(out));
+
+    expect(view.set).not.toHaveBeenCalled();
+    expect(emitted).toEqual([
+      {
+        type: 'import-result',
+        target,
+        ok: true,
+        written: 0,
+        total: 0,
+      },
+    ]);
+  });
+});

package/src/react-native/adapters/__tests__/mmkv.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createMMKVStorageAdapter } from '../mmkv';
+import { createStorageViews } from '../../storage-view';
+
+type StoredValue = string | number | boolean | ArrayBuffer;
+
+const createFakeMMKVV3 = (id: string) => {
+  const values = new Map<string, StoredValue>();
+
+  return {
+    id,
+    set: vi.fn((key: string, value: StoredValue) => {
+      values.set(key, value);
+    }),
+    getBoolean: vi.fn((key: string) => {
+      const value = values.get(key);
+      return typeof value === 'boolean' ? value : undefined;
+    }),
+    getString: vi.fn((key: string) => {
+      const value = values.get(key);
+      return typeof value === 'string' ? value : undefined;
+    }),
+    getNumber: vi.fn((key: string) => {
+      const value = values.get(key);
+      return typeof value === 'number' ? value : undefined;
+    }),
+    getBuffer: vi.fn((key: string) => {
+      const value = values.get(key);
+      return value instanceof ArrayBuffer ? value : undefined;
+    }),
+    delete: vi.fn((key: string) => {
+      values.delete(key);
+    }),
+    getAllKeys: vi.fn(() => [...values.keys()]),
+    addOnValueChangedListener: vi.fn(() => ({ remove: vi.fn() })),
+  };
+};
+
+const createFakeMMKVV4 = () => {
+  const values = new Map<string, StoredValue>();
+
+  return {
+    set: vi.fn((key: string, value: StoredValue) => {
+      values.set(key, value);
+    }),
+    getBoolean: vi.fn((key: string) => {
+      const value = values.get(key);
+      return typeof value === 'boolean' ? value : undefined;
+    }),
+    getString: vi.fn((key: string) => {
+      const value = values.get(key);
+      return typeof value === 'string' ? value : undefined;
+    }),
+    getNumber: vi.fn((key: string) => {
+      const value = values.get(key);
+      return typeof value === 'number' ? value : undefined;
+    }),
+    getBuffer: vi.fn((key: string) => {
+      const value = values.get(key);
+      return value instanceof ArrayBuffer ? value : undefined;
+    }),
+    remove: vi.fn((key: string) => {
+      values.delete(key);
+    }),
+    getAllKeys: vi.fn(() => [...values.keys()]),
+    addOnValueChangedListener: vi.fn(() => ({ remove: vi.fn() })),
+  };
+};
+
+describe('createMMKVStorageAdapter', () => {
+  it('supports MMKV v3 storages passed as an array', async () => {
+    const storage = createFakeMMKVV3('user-storage');
+    const adapter = createMMKVStorageAdapter({ storages: [storage as any] });
+    const [view] = createStorageViews([adapter]);
+
+    await view.set({ key: 'theme', type: 'string', value: 'dark' });
+
+    expect(view.target).toEqual({
+      adapterId: 'mmkv',
+      storageId: 'user-storage',
+    });
+    await expect(view.get('theme')).resolves.toEqual({
+      key: 'theme',
+      type: 'string',
+      value: 'dark',
+    });
+  });
+
+  it('supports MMKV v4 storages passed as a record', async () => {
+    const storage = createFakeMMKVV4();
+    const adapter = createMMKVStorageAdapter({
+      storages: { 'user-storage': storage as any },
+    });
+    const [view] = createStorageViews([adapter]);
+
+    await view.set({ key: 'logged-in', type: 'boolean', value: true });
+    await expect(view.get('logged-in')).resolves.toEqual({
+      key: 'logged-in',
+      type: 'boolean',
+      value: true,
+    });
+
+    await view.delete('logged-in');
+
+    expect(storage.remove).toHaveBeenCalledWith('logged-in');
+    await expect(view.get('logged-in')).resolves.toBeUndefined();
+  });
+
+  it('rejects MMKV v4 storages passed as an array', () => {
+    const storage = createFakeMMKVV4();
+
+    expect(() => createMMKVStorageAdapter({ storages: [storage as any] })).toThrow(
+      /MMKV arrays are not supported for v4 storages/
+    );
+  });
+
+  it('applies global blacklist patterns against storageId:key', async () => {
+    const userStorage = createFakeMMKVV3('user-storage');
+    const cacheStorage = createFakeMMKVV3('cache-storage');
+
+    userStorage.set('visible', 'ok');
+    userStorage.set('secret', 'hide');
+    cacheStorage.set('temp-file', 'hide');
+    cacheStorage.set('persisted', 'ok');
+
+    const adapter = createMMKVStorageAdapter({
+      storages: [userStorage as any, cacheStorage as any],
+      blacklist: /user-storage:secret|cache-storage:temp.*/,
+    });
+
+    const views = createStorageViews([adapter]);
+    const userView = views.find((view) => view.target.storageId === 'user-storage');
+    const cacheView = views.find((view) => view.target.storageId === 'cache-storage');
+
+    expect(userView).toBeDefined();
+    expect(cacheView).toBeDefined();
+
+    await expect(userView?.getAllKeys()).resolves.toEqual(['visible']);
+    await expect(cacheView?.getAllKeys()).resolves.toEqual(['persisted']);
+  });
+});

package/src/react-native/adapters/mmkv.ts

@@ -148,6 +148,20 @@ const getStorageBlacklist = (
   return config[storageId];
 };
 
+const createStorageBlacklistMatcher = (
+  config: MMKVBlacklistConfig | undefined,
+  storageId: string
+) => {
+  if (!(config instanceof RegExp)) {
+    return undefined;
+  }
+
+  return (key: string) => {
+    config.lastIndex = 0;
+    return config.test(`${storageId}:${key}`);
+  };
+};
+
 export const createMMKVStorageAdapter = ({
   adapterId = 'mmkv',
   adapterName = 'MMKV',
@@ -164,6 +178,7 @@ export const createMMKVStorageAdapter = ({
         id: storageId,
         name: storageId,
         blacklist: getStorageBlacklist(blacklist, storageId),
+        shouldFilterKey: createStorageBlacklistMatcher(blacklist, storageId),
         capabilities: {
           supportedTypes: DEFAULT_SUPPORTED_TYPES,
         },

package/src/react-native/import.ts

@@ -0,0 +1,67 @@
+import type {
+  StorageImportEntriesEvent,
+  StorageImportResultEvent,
+  StorageSetEntryEvent,
+} from '../shared/messaging';
+import type { StorageView } from './storage-view';
+
+export type ImportEmittedEvent =
+  | StorageSetEntryEvent
+  | StorageImportResultEvent;
+
+export const handleImportEntries = async (
+  views: StorageView[],
+  event: StorageImportEntriesEvent,
+  emit: (out: ImportEmittedEvent) => void,
+): Promise<void> => {
+  const view = views.find(
+    (candidate) =>
+      candidate.target.adapterId === event.target.adapterId &&
+      candidate.target.storageId === event.target.storageId,
+  );
+
+  if (!view) {
+    emit({
+      type: 'import-result',
+      target: event.target,
+      ok: false,
+      written: 0,
+      total: event.entries.length,
+      error: 'Target storage not found',
+    });
+    return;
+  }
+
+  for (let i = 0; i < event.entries.length; i++) {
+    const entry = event.entries[i];
+
+    try {
+      await view.set(entry);
+    } catch (error) {
+      emit({
+        type: 'import-result',
+        target: event.target,
+        ok: false,
+        written: i,
+        total: event.entries.length,
+        failedKey: entry.key,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return;
+    }
+
+    emit({
+      type: 'set-entry',
+      target: event.target,
+      entry,
+    });
+  }
+
+  emit({
+    type: 'import-result',
+    target: event.target,
+    ok: true,
+    written: event.entries.length,
+    total: event.entries.length,
+  });
+};

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

@@ -34,6 +34,10 @@ const toSnapshotMap = (entries: StorageEntry[]) => {
 };
 
 const shouldFilterKey = (storage: StorageNode, key: string) => {
+  if (storage.shouldFilterKey?.(key)) {
+    return true;
+  }
+
   if (!storage.blacklist) {
     return false;
   }
@@ -45,14 +49,14 @@ const shouldFilterKey = (storage: StorageNode, key: string) => {
 const checkTypeSupport = (
   capabilities: StorageCapabilities,
   type: StorageEntryType,
-  target: StorageTarget
+  target: StorageTarget,
 ) => {
   if (supportsType(capabilities, type)) {
     return;
   }
 
   throw new Error(
-    `Type "${type}" is not supported by storage "${target.storageId}" in adapter "${target.adapterId}".`
+    `Type "${type}" is not supported by storage "${target.storageId}" in adapter "${target.adapterId}".`,
   );
 };
 
@@ -96,6 +100,7 @@ export type StorageView = {
   adapterName: string;
   storageName: string;
   capabilities: StorageCapabilities;
+  blacklist?: RegExp;
   get: (key: string) => Promise<StorageEntry | undefined>;
   set: (entry: StorageEntry) => Promise<void>;
   delete: (key: string) => Promise<void>;
@@ -108,7 +113,7 @@ export type StorageView = {
 };
 
 const buildSnapshotMap = async (
-  getAllEntries: () => Promise<StorageEntry[]>
+  getAllEntries: () => Promise<StorageEntry[]>,
 ): Promise<StorageSnapshotMap> => {
   const entries = await getAllEntries();
   return toSnapshotMap(entries);
@@ -120,7 +125,7 @@ const diffSnapshots = (
   handlers: {
     onSet: (entry: StorageEntry) => void;
     onDelete: (key: string) => void;
-  }
+  },
 ) => {
   next.forEach((nextEntry, key) => {
     const previousEntry = previous.get(key);
@@ -147,7 +152,7 @@ const createPollingSubscription = async (
   handlers: {
     onSet: (entry: StorageEntry) => void;
     onDelete: (key: string) => void;
-  }
+  },
 ): Promise<StorageSubscription> => {
   let previousSnapshot = await buildSnapshotMap(getAllEntries);
 
@@ -170,7 +175,7 @@ const createPollingSubscription = async (
 
 export const createStorageView = (
   adapter: StorageAdapter,
-  storageNode: StorageNode
+  storageNode: StorageNode,
 ): StorageView => {
   const storage = storageNode.storage;
   const target: StorageTarget = {
@@ -191,7 +196,7 @@ export const createStorageView = (
     const visibleEntries = await Promise.all(
       keys
         .filter((key) => !shouldFilterKey(storageNode, key))
-        .map((key) => getEntry(storage, key))
+        .map((key) => getEntry(storage, key)),
     );
 
     return visibleEntries.filter((entry): entry is StorageEntry => !!entry);
@@ -203,6 +208,7 @@ export const createStorageView = (
     adapterName: adapter.name,
     storageName: storageNode.name,
     capabilities: storageNode.capabilities,
+    blacklist: storageNode.blacklist,
     get,
     set: async (entry) => {
       checkTypeSupport(storageNode.capabilities, entry.type, target);
@@ -241,5 +247,7 @@ export const createStorageView = (
 
 export const createStorageViews = (storages: StorageAdapter[]) =>
   storages.flatMap((adapter) =>
-    adapter.storages.map((storageNode) => createStorageView(adapter, storageNode))
+    adapter.storages.map((storageNode) =>
+      createStorageView(adapter, storageNode),
+    ),
   );