@rozenite/storage-plugin 1.13.0 → 2.0.0

package/src/react-native/__tests__/entry-preview-pagination.test.ts

@@ -0,0 +1,262 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { StorageAdapter, StorageEntry } from '../../shared/types';
+import {
+  ENTRY_PREVIEW_READ_CONCURRENCY,
+  MAX_ENTRY_PREVIEW_PAGE_SIZE,
+  handleListEntryPreviewsRequest,
+} from '../entry-preview-pagination';
+import { createStorageViews } from '../storage-view';
+
+const target = { adapterId: 'adapter', storageId: 'storage' };
+
+const createView = (
+  values: Record<string, StorageEntry>,
+  options?: {
+    blacklist?: RegExp;
+    get?: (
+      key: string,
+    ) => StorageEntry | undefined | Promise<StorageEntry | undefined>;
+  },
+) => {
+  const get = vi.fn(options?.get ?? ((key: string) => values[key]));
+  const getAllKeys = vi.fn(() => Object.keys(values));
+  const adapter: StorageAdapter = {
+    id: target.adapterId,
+    name: 'Adapter',
+    storages: [
+      {
+        id: target.storageId,
+        name: 'Storage',
+        capabilities: { supportedTypes: ['string'] },
+        blacklist: options?.blacklist,
+        storage: {
+          kind: 'sync',
+          getAllKeys,
+          get: get as (key: string) => StorageEntry | undefined,
+          set: vi.fn(),
+          delete: vi.fn(),
+          clear: vi.fn(),
+        },
+      },
+    ],
+  };
+
+  return { view: createStorageViews([adapter])[0], get, getAllKeys };
+};
+
+const entries = (...keys: string[]): Record<string, StorageEntry> =>
+  Object.fromEntries(
+    keys.map((key) => [key, { key, type: 'string', value: `value:${key}` }]),
+  );
+
+const request = (overrides: Record<string, unknown> = {}) => ({
+  type: 'list-entry-previews' as const,
+  requestId: 'request-1',
+  target,
+  limit: 2,
+  ...overrides,
+});
+
+describe('handleListEntryPreviewsRequest', () => {
+  it('returns sorted first, next, and previous pages without reading outside each page', async () => {
+    const { view, get } = createView(
+      entries('delta', 'bravo', 'alpha', 'charlie', 'echo'),
+    );
+
+    const first = await handleListEntryPreviewsRequest([view], request());
+    expect(first).toMatchObject({
+      type: 'entry-previews',
+      items: [{ key: 'alpha' }, { key: 'bravo' }],
+    });
+    expect(get).toHaveBeenCalledTimes(2);
+
+    const next = await handleListEntryPreviewsRequest(
+      [view],
+      request({
+        cursor: first.type === 'entry-previews' ? first.nextCursor : undefined,
+      }),
+    );
+    expect(next).toMatchObject({
+      type: 'entry-previews',
+      items: [{ key: 'charlie' }, { key: 'delta' }],
+    });
+    expect(get).toHaveBeenCalledTimes(4);
+
+    const previous = await handleListEntryPreviewsRequest(
+      [view],
+      request({
+        cursor:
+          next.type === 'entry-previews' ? next.previousCursor : undefined,
+      }),
+    );
+    expect(previous).toMatchObject({
+      type: 'entry-previews',
+      items: [{ key: 'alpha' }, { key: 'bravo' }],
+    });
+    expect(get).toHaveBeenCalledTimes(6);
+  });
+
+  it('filters normalized key search and sorts before pagination without inspecting non-page values', async () => {
+    const { view, get } = createView(
+      entries('Alpha', 'alphabet', 'beta', 'ALPINE'),
+    );
+
+    const result = await handleListEntryPreviewsRequest(
+      [view],
+      request({ search: ' ALP ', keySortDirection: 'descending', limit: 1 }),
+    );
+
+    expect(result).toMatchObject({
+      type: 'entry-previews',
+      items: [{ key: 'alphabet' }],
+    });
+    expect(get).toHaveBeenCalledWith('alphabet');
+    expect(get).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns empty and final pages without cursors', async () => {
+    const { view, get } = createView(entries('only'));
+
+    await expect(
+      handleListEntryPreviewsRequest([view], request({ search: 'missing' })),
+    ).resolves.toEqual({
+      type: 'entry-previews',
+      requestId: 'request-1',
+      target,
+      items: [],
+    });
+    await expect(
+      handleListEntryPreviewsRequest([view], request()),
+    ).resolves.toEqual({
+      type: 'entry-previews',
+      requestId: 'request-1',
+      target,
+      items: [
+        {
+          key: 'only',
+          type: 'string',
+          preview: 'value:only',
+          valueSize: 10,
+          isTruncated: false,
+        },
+      ],
+    });
+    expect(get).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects malformed, mismatched, and stale cursors with a reset signal', async () => {
+    const { view } = createView(entries('alpha', 'bravo', 'charlie'));
+
+    await expect(
+      handleListEntryPreviewsRequest(
+        [view],
+        request({ cursor: 'not-a-cursor' }),
+      ),
+    ).resolves.toMatchObject({ code: 'INVALID_CURSOR', resetPagination: true });
+
+    const first = await handleListEntryPreviewsRequest([view], request());
+    const cursor = first.type === 'entry-previews' ? first.nextCursor! : '';
+    await expect(
+      handleListEntryPreviewsRequest(
+        [view],
+        request({ search: 'alpha', cursor }),
+      ),
+    ).resolves.toMatchObject({ code: 'INVALID_CURSOR', resetPagination: true });
+
+    const stale = await handleListEntryPreviewsRequest(
+      [view],
+      request({ cursor }),
+    );
+    expect(stale).toMatchObject({ type: 'entry-previews' });
+    const noBoundary = createView(entries('alpha', 'charlie')).view;
+    await expect(
+      handleListEntryPreviewsRequest([noBoundary], request({ cursor })),
+    ).resolves.toMatchObject({ code: 'INVALID_CURSOR', resetPagination: true });
+  });
+
+  it('applies blacklist rules before pagination and caps oversized page limits', async () => {
+    const { view, get } = createView(
+      entries(
+        ...Array.from(
+          { length: MAX_ENTRY_PREVIEW_PAGE_SIZE + 2 },
+          (_, index) => `key-${index}`,
+        ),
+        'secret',
+      ),
+      { blacklist: /^secret$/ },
+    );
+
+    const result = await handleListEntryPreviewsRequest(
+      [view],
+      request({ limit: MAX_ENTRY_PREVIEW_PAGE_SIZE + 50 }),
+    );
+
+    expect(result).toMatchObject({ type: 'entry-previews' });
+    expect(get).toHaveBeenCalledTimes(MAX_ENTRY_PREVIEW_PAGE_SIZE);
+    expect(get).not.toHaveBeenCalledWith('secret');
+  });
+
+  it('bounds concurrent page reads and converts values to previews before returning', async () => {
+    let activeReads = 0;
+    let maxActiveReads = 0;
+    const { view } = createView(entries('a', 'b', 'c', 'd', 'e'), {
+      get: async (key) => {
+        activeReads += 1;
+        maxActiveReads = Math.max(maxActiveReads, activeReads);
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        activeReads -= 1;
+        return { key, type: 'string', value: 'x'.repeat(300) };
+      },
+    });
+
+    const result = await handleListEntryPreviewsRequest(
+      [view],
+      request({ limit: 5 }),
+    );
+
+    expect(maxActiveReads).toBeLessThanOrEqual(ENTRY_PREVIEW_READ_CONCURRENCY);
+    expect(result).toMatchObject({
+      type: 'entry-previews',
+      items: expect.arrayContaining([
+        expect.objectContaining({
+          preview: 'x'.repeat(256),
+          isTruncated: true,
+        }),
+      ]),
+    });
+    if (result.type === 'entry-previews') {
+      expect(result.items.every((item) => !('value' in item))).toBe(true);
+    }
+  });
+
+  it('contains page-read failures in a structured response', async () => {
+    const { view } = createView(entries('a', 'b'), {
+      get: (key) => {
+        if (key === 'a') {
+          throw new Error('adapter internals');
+        }
+        return { key, type: 'string', value: 'value' };
+      },
+    });
+
+    await expect(
+      handleListEntryPreviewsRequest([view], request()),
+    ).resolves.toEqual({
+      type: 'storage-request-error',
+      requestId: 'request-1',
+      code: 'READ_FAILED',
+      message: 'Failed to read entry previews from the requested storage.',
+    });
+  });
+
+  it('rejects non-finite and non-positive limits without reading storage', async () => {
+    const { view, getAllKeys } = createView(entries('key'));
+
+    for (const limit of [0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
+      await expect(
+        handleListEntryPreviewsRequest([view], request({ limit })),
+      ).resolves.toMatchObject({ code: 'INVALID_REQUEST' });
+    }
+    expect(getAllKeys).not.toHaveBeenCalled();
+  });
+});

package/src/react-native/__tests__/export-snapshot.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { StorageAdapter, StorageEntry } from '../../shared/types';
+import { handleExportSnapshotRequest } from '../export-snapshot';
+import { createStorageViews } from '../storage-view';
+
+const target = { adapterId: 'adapter', storageId: 'storage' };
+
+const request = (overrides: Record<string, unknown> = {}) => ({
+  type: 'export-snapshot' as const,
+  requestId: 'request-1',
+  target,
+  ...overrides,
+});
+
+const createView = (
+  values: Record<string, StorageEntry>,
+  options?: { blacklist?: RegExp; getAllKeys?: () => string[] },
+) => {
+  const get = vi.fn((key: string) => values[key]);
+  const getAllKeys = vi.fn(options?.getAllKeys ?? (() => Object.keys(values)));
+  const adapter: StorageAdapter = {
+    id: target.adapterId,
+    name: 'Adapter',
+    storages: [
+      {
+        id: target.storageId,
+        name: 'Storage',
+        capabilities: { supportedTypes: ['string', 'buffer'] },
+        blacklist: options?.blacklist,
+        storage: {
+          kind: 'sync',
+          getAllKeys,
+          get: get as (key: string) => StorageEntry | undefined,
+          set: vi.fn(),
+          delete: vi.fn(),
+          clear: vi.fn(),
+        },
+      },
+    ],
+  };
+
+  return { view: createStorageViews([adapter])[0], get, getAllKeys };
+};
+
+describe('handleExportSnapshotRequest', () => {
+  it('builds a schema-compatible snapshot from current device entries only when requested', async () => {
+    const { view, get, getAllKeys } = createView(
+      {
+        retained: { key: 'retained', type: 'string', value: 'old UI page' },
+        unseen: {
+          key: 'unseen',
+          type: 'string',
+          value: 'current device value',
+        },
+        secret: { key: 'secret', type: 'string', value: 'excluded' },
+      },
+      { blacklist: /^secret$/ },
+    );
+
+    expect(getAllKeys).not.toHaveBeenCalled();
+    expect(get).not.toHaveBeenCalled();
+
+    const result = await handleExportSnapshotRequest([view], request());
+
+    expect(result).toMatchObject({
+      type: 'export-snapshot-result',
+      requestId: 'request-1',
+      target,
+      snapshot: {
+        version: 1,
+        plugin: '@rozenite/storage-plugin',
+        storage: {
+          adapterId: 'adapter',
+          storageId: 'storage',
+          adapterName: 'Adapter',
+          storageName: 'Storage',
+        },
+        entries: [
+          { key: 'retained', type: 'string', value: 'old UI page' },
+          { key: 'unseen', type: 'string', value: 'current device value' },
+        ],
+      },
+    });
+    expect(getAllKeys).toHaveBeenCalledTimes(1);
+    expect(get).toHaveBeenCalledTimes(2);
+    expect(get).not.toHaveBeenCalledWith('secret');
+  });
+
+  it('exports an empty storage as a valid empty snapshot', async () => {
+    const { view } = createView({});
+
+    await expect(
+      handleExportSnapshotRequest([view], request()),
+    ).resolves.toMatchObject({
+      type: 'export-snapshot-result',
+      snapshot: { entries: [] },
+    });
+  });
+
+  it('returns predictable invalid and missing-target errors', async () => {
+    const { view } = createView({});
+
+    await expect(
+      handleExportSnapshotRequest(
+        [view],
+        request({ target: { adapterId: '', storageId: 'storage' } }),
+      ),
+    ).resolves.toMatchObject({
+      code: 'INVALID_REQUEST',
+      requestId: 'request-1',
+    });
+    await expect(
+      handleExportSnapshotRequest(
+        [view],
+        request({ target: { adapterId: 'missing', storageId: 'storage' } }),
+      ),
+    ).resolves.toMatchObject({
+      code: 'TARGET_NOT_FOUND',
+      requestId: 'request-1',
+    });
+  });
+
+  it('contains device read failures without exposing adapter errors', async () => {
+    const { view } = createView(
+      {},
+      {
+        getAllKeys: () => {
+          throw new Error('adapter internals');
+        },
+      },
+    );
+
+    await expect(
+      handleExportSnapshotRequest([view], request()),
+    ).resolves.toEqual({
+      type: 'storage-request-error',
+      requestId: 'request-1',
+      code: 'READ_FAILED',
+      message: 'Failed to export the requested storage.',
+    });
+  });
+});

package/src/react-native/__tests__/full-entry-request.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { StorageAdapter, StorageEntry } from '../../shared/types';
+import { handleFullEntryRequest } from '../full-entry-request';
+import { createStorageViews } from '../storage-view';
+
+const target = { adapterId: 'adapter', storageId: 'storage' };
+
+const request = (overrides: Record<string, unknown> = {}) => ({
+  type: 'get-entry' as const,
+  requestId: 'request-1',
+  target,
+  key: 'key',
+  ...overrides,
+});
+
+const createView = (
+  values: Record<string, StorageEntry>,
+  options?: {
+    blacklist?: RegExp;
+    get?: (
+      key: string,
+    ) => StorageEntry | undefined | Promise<StorageEntry | undefined>;
+  },
+) => {
+  const get = vi.fn(options?.get ?? ((key: string) => values[key]));
+  const getAllKeys = vi.fn(() => Object.keys(values));
+  const adapter: StorageAdapter = {
+    id: target.adapterId,
+    name: 'Adapter',
+    storages: [
+      {
+        id: target.storageId,
+        name: 'Storage',
+        capabilities: { supportedTypes: ['string', 'buffer'] },
+        blacklist: options?.blacklist,
+        storage: {
+          kind: 'sync',
+          getAllKeys,
+          get: get as (key: string) => StorageEntry | undefined,
+          set: vi.fn(),
+          delete: vi.fn(),
+          clear: vi.fn(),
+        },
+      },
+    ],
+  };
+
+  return { view: createStorageViews([adapter])[0], get, getAllKeys };
+};
+
+describe('handleFullEntryRequest', () => {
+  it('reads exactly the requested key and returns its complete typed value', async () => {
+    const buffer = Array.from({ length: 4_096 }, (_, index) => index % 256);
+    const { view, get, getAllKeys } = createView({
+      key: { key: 'key', type: 'buffer', value: buffer },
+      other: { key: 'other', type: 'string', value: 'not read' },
+    });
+
+    await expect(handleFullEntryRequest([view], request())).resolves.toEqual({
+      type: 'entry',
+      requestId: 'request-1',
+      target,
+      entry: { key: 'key', type: 'buffer', value: buffer },
+    });
+    expect(get).toHaveBeenCalledTimes(1);
+    expect(get).toHaveBeenCalledWith('key');
+    expect(getAllKeys).not.toHaveBeenCalled();
+  });
+
+  it('returns structured errors for missing, blacklisted, invalid, and unknown targets', async () => {
+    const missing = createView({});
+    await expect(
+      handleFullEntryRequest([missing.view], request()),
+    ).resolves.toMatchObject({
+      type: 'storage-request-error',
+      requestId: 'request-1',
+      code: 'ENTRY_NOT_FOUND',
+    });
+
+    const blacklisted = createView(
+      { key: { key: 'key', type: 'string', value: 'secret' } },
+      { blacklist: /^key$/ },
+    );
+    await expect(
+      handleFullEntryRequest([blacklisted.view], request()),
+    ).resolves.toMatchObject({
+      code: 'ENTRY_NOT_FOUND',
+    });
+    expect(blacklisted.get).not.toHaveBeenCalled();
+
+    await expect(
+      handleFullEntryRequest([missing.view], request({ key: 42 })),
+    ).resolves.toMatchObject({ code: 'INVALID_REQUEST' });
+    await expect(
+      handleFullEntryRequest(
+        [missing.view],
+        request({ target: { adapterId: 'missing', storageId: 'storage' } }),
+      ),
+    ).resolves.toMatchObject({ code: 'TARGET_NOT_FOUND' });
+  });
+
+  it('contains adapter read failures without exposing adapter errors', async () => {
+    const { view } = createView(
+      {},
+      {
+        get: () => {
+          throw new Error('adapter internals');
+        },
+      },
+    );
+
+    await expect(handleFullEntryRequest([view], request())).resolves.toEqual({
+      type: 'storage-request-error',
+      requestId: 'request-1',
+      code: 'READ_FAILED',
+      message: 'Failed to read the requested storage entry.',
+    });
+  });
+
+  it('keeps concurrent requests correlated', async () => {
+    const resolvers = new Map<string, (entry: StorageEntry) => void>();
+    const { view, get } = createView(
+      {},
+      {
+        get: (key) =>
+          new Promise<StorageEntry>((resolve) => {
+            resolvers.set(key, resolve);
+          }),
+      },
+    );
+    const first = handleFullEntryRequest(
+      [view],
+      request({ requestId: 'first', key: 'first' }),
+    );
+    const second = handleFullEntryRequest(
+      [view],
+      request({ requestId: 'second', key: 'second' }),
+    );
+
+    await vi.waitFor(() => expect(get).toHaveBeenCalledTimes(2));
+    resolvers.get('second')?.({ key: 'second', type: 'string', value: 'two' });
+    resolvers.get('first')?.({ key: 'first', type: 'string', value: 'one' });
+
+    await expect(first).resolves.toMatchObject({
+      type: 'entry',
+      requestId: 'first',
+      entry: { key: 'first', value: 'one' },
+    });
+    await expect(second).resolves.toMatchObject({
+      type: 'entry',
+      requestId: 'second',
+      entry: { key: 'second', value: 'two' },
+    });
+  });
+});