@rozenite/storage-plugin 1.8.1 → 1.10.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.1","description":"Generic Storage Inspector for Rozenite.","panels":[{"name":"Storage","source":"/devtools/panel.html"}]}
+{"name":"@rozenite/storage-plugin","version":"1.10.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.1",
+  "version": "1.10.0",
   "description": "Generic Storage Inspector for Rozenite.",
   "type": "module",
   "main": "./dist/react-native/index.cjs",
@@ -15,11 +15,14 @@
     "url": "https://github.com/callstackincubator/rozenite.git"
   },
   "dependencies": {
-    "@rozenite/agent-shared": "1.8.1",
-    "@rozenite/agent-bridge": "1.8.1",
-    "@rozenite/plugin-bridge": "1.8.1"
+    "@rozenite/agent-shared": "1.10.0",
+    "@rozenite/agent-bridge": "1.10.0",
+    "@rozenite/plugin-bridge": "1.10.0"
   },
   "devDependencies": {
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/view": "^6.40.0",
     "@tanstack/react-table": "^8.21.3",
     "@types/react": "~19.2.2",
     "autoprefixer": "^10.4.21",
@@ -38,8 +41,8 @@
     "tailwindcss-animate": "^1.0.7",
     "typescript": "~5.9.3",
     "vite": "^7.3.1",
-    "@rozenite/vite-plugin": "1.8.1",
-    "rozenite": "1.8.1"
+    "@rozenite/vite-plugin": "1.10.0",
+    "rozenite": "1.10.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,
+      },
+    ]);
+  });
+});