@rozenite/storage-plugin 2.2.0 → 2.3.0

package/dist/react-native/src/react-native/adapters/async-storage.d.ts

@@ -0,0 +1,34 @@
+import type { StorageAdapter } from '../../shared/types';
+export type AsyncStorageLike = {
+    getAllKeys: () => Promise<readonly string[]>;
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+};
+export type AsyncStorageInstanceConfig = {
+    storage: AsyncStorageLike;
+    name?: string;
+    blacklist?: RegExp;
+};
+type SingleStorageOptions = {
+    storage: AsyncStorageLike;
+    adapterId?: string;
+    adapterName?: string;
+    storageId?: string;
+    storageName?: string;
+    blacklist?: RegExp;
+};
+type MultiStorageOptions = {
+    storages: Record<string, AsyncStorageLike | AsyncStorageInstanceConfig>;
+    adapterId?: string;
+    adapterName?: string;
+};
+export type CreateAsyncStorageAdapterOptions = SingleStorageOptions | MultiStorageOptions;
+export declare const createAsyncStorageAdapter: (options: CreateAsyncStorageAdapterOptions) => StorageAdapter;
+/**
+ * @deprecated Use createAsyncStorageAdapter instead.
+ */
+export declare const createExpoAsyncStorageAdapter: (options: CreateAsyncStorageAdapterOptions) => StorageAdapter;
+export type CreateExpoAsyncStorageAdapterOptions = CreateAsyncStorageAdapterOptions;
+export {};

package/dist/react-native/src/react-native/adapters/async-storage.js

@@ -0,0 +1,56 @@
+const toStorageNode = (storageId, config, fallbackName, fallbackBlacklist) => {
+    const resolved = 'storage' in config
+        ? config
+        : {
+            storage: config,
+        };
+    const { storage, name, blacklist } = resolved;
+    return {
+        id: storageId,
+        name: name ?? fallbackName ?? storageId,
+        blacklist: blacklist ?? fallbackBlacklist,
+        capabilities: {
+            supportedTypes: ['string'],
+        },
+        storage: {
+            kind: 'async',
+            getAllKeys: () => storage.getAllKeys(),
+            get: async (key) => {
+                const value = await storage.getItem(key);
+                if (value === null) {
+                    return undefined;
+                }
+                return {
+                    key,
+                    type: 'string',
+                    value,
+                };
+            },
+            set: async (entry) => {
+                if (entry.type !== 'string') {
+                    throw new Error('AsyncStorage adapter supports only string values.');
+                }
+                await storage.setItem(entry.key, entry.value);
+            },
+            delete: (key) => storage.removeItem(key),
+            clear: () => storage.clear(),
+        },
+    };
+};
+export const createAsyncStorageAdapter = (options) => {
+    const { adapterId = 'async-storage', adapterName = 'AsyncStorage' } = options;
+    const storageNodes = 'storages' in options
+        ? Object.entries(options.storages).map(([storageId, config]) => toStorageNode(storageId, config))
+        : [
+            toStorageNode(options.storageId ?? 'default', options.storage, options.storageName ?? 'Default Storage', options.blacklist),
+        ];
+    return {
+        id: adapterId,
+        name: adapterName,
+        storages: storageNodes,
+    };
+};
+/**
+ * @deprecated Use createAsyncStorageAdapter instead.
+ */
+export const createExpoAsyncStorageAdapter = createAsyncStorageAdapter;

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

@@ -0,0 +1,6 @@
+export { createMMKVStorageAdapter } from './mmkv';
+export type { CreateMMKVStorageAdapterOptions } from './mmkv';
+export { createAsyncStorageAdapter, createExpoAsyncStorageAdapter } from './async-storage';
+export type { AsyncStorageInstanceConfig, AsyncStorageLike, CreateAsyncStorageAdapterOptions, CreateExpoAsyncStorageAdapterOptions, } from './async-storage';
+export { createExpoSecureStorageAdapter } from './secure-storage';
+export type { CreateExpoSecureStorageAdapterOptions, SecureStorageLike } from './secure-storage';

package/dist/react-native/src/react-native/adapters/index.js

@@ -0,0 +1,3 @@
+export { createMMKVStorageAdapter } from './mmkv';
+export { createAsyncStorageAdapter, createExpoAsyncStorageAdapter } from './async-storage';
+export { createExpoSecureStorageAdapter } from './secure-storage';

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

@@ -0,0 +1,13 @@
+import type { MMKV as MMKVV3 } from 'react-native-mmkv-v3';
+import type { MMKV as MMKVV4 } from 'react-native-mmkv-v4';
+import type { StorageAdapter } from '../../shared/types';
+type MMKV = MMKVV3 | MMKVV4;
+export type MMKVBlacklistConfig = RegExp | Record<string, RegExp | undefined>;
+export type CreateMMKVStorageAdapterOptions = {
+    adapterId?: string;
+    adapterName?: string;
+    storages: MMKV[] | Record<string, MMKV>;
+    blacklist?: MMKVBlacklistConfig;
+};
+export declare const createMMKVStorageAdapter: ({ adapterId, adapterName, storages, blacklist, }: CreateMMKVStorageAdapterOptions) => StorageAdapter;
+export {};

package/dist/react-native/src/react-native/adapters/mmkv.js

@@ -0,0 +1,139 @@
+import { DEFAULT_SUPPORTED_TYPES } from '../../shared/types';
+const isMMKVV4 = (mmkv) => 'remove' in mmkv;
+const normalizeStorages = (storages) => {
+    if (Array.isArray(storages)) {
+        const isAnyStorageV4 = storages.some(isMMKVV4);
+        if (isAnyStorageV4) {
+            throw new Error('[Rozenite] Storage Plugin: MMKV arrays are not supported for v4 storages. Pass a record of storage IDs and MMKV instances.');
+        }
+        return Object.fromEntries(storages.map((storage) => [storage['id'], storage]));
+    }
+    return storages;
+};
+const getMMKVAdapter = (mmkv) => {
+    const clear = () => mmkv.clearAll();
+    if (isMMKVV4(mmkv)) {
+        return {
+            set: (key, value) => mmkv.set(key, value),
+            getBoolean: (key) => mmkv.getBoolean(key),
+            getString: (key) => mmkv.getString(key),
+            getNumber: (key) => mmkv.getNumber(key),
+            getBuffer: (key) => mmkv.getBuffer(key),
+            delete: (key) => mmkv.remove(key),
+            getAllKeys: () => mmkv.getAllKeys(),
+            clear,
+            addOnValueChangedListener: (callback) => mmkv.addOnValueChangedListener(callback),
+        };
+    }
+    return {
+        set: (key, value) => mmkv.set(key, value),
+        getBoolean: (key) => mmkv.getBoolean(key),
+        getString: (key) => mmkv.getString(key),
+        getNumber: (key) => mmkv.getNumber(key),
+        getBuffer: (key) => mmkv.getBuffer(key),
+        delete: (key) => mmkv.delete(key),
+        getAllKeys: () => mmkv.getAllKeys(),
+        clear,
+        addOnValueChangedListener: (callback) => mmkv.addOnValueChangedListener(callback),
+    };
+};
+// MMKV's typed getters can disagree on the same key — on some platforms
+// `getString` lenient-decodes invalid-UTF-8 buffer bytes to `""`, and
+// `getNumber` reinterprets 8-byte buffers as IEEE 754 doubles without
+// honoring the original `setBuffer` write. `getBuffer` is more reliably
+// strict (only returns for keys actually written via `setBuffer`), so
+// we consult it ahead of the numeric getters to break ties in favour of
+// the bytes that are actually on disk.
+//
+//   1. Non-empty string — the common case. Buffer bytes that happen to
+//      be valid UTF-8 surface here too (documented trade-off); users
+//      disambiguate at edit time via the Hex editor.
+//   2. Non-empty buffer — catches `setBuffer` payloads regardless of
+//      byte count and regardless of whether the other typed getters
+//      also return spurious values.
+//   3. Number, then boolean — for keys actually written via `setNumber`
+//      / `setBoolean`. `getBuffer` will have returned `undefined` for
+//      those keys, so the chain falls through.
+//   4. Empty string — intentional `setString(key, "")` lands here once
+//      we've ruled out a non-empty buffer payload at the same key.
+const getEntry = (adapter, key) => {
+    const stringValue = adapter.getString(key);
+    if (stringValue !== undefined && stringValue.length > 0) {
+        return { key, type: 'string', value: stringValue };
+    }
+    const bufferValue = adapter.getBuffer(key);
+    if (bufferValue !== undefined && bufferValue.byteLength > 0) {
+        return {
+            key,
+            type: 'buffer',
+            value: Array.from(new Uint8Array(bufferValue)),
+        };
+    }
+    const numberValue = adapter.getNumber(key);
+    if (numberValue !== undefined) {
+        return { key, type: 'number', value: numberValue };
+    }
+    const booleanValue = adapter.getBoolean(key);
+    if (booleanValue !== undefined) {
+        return { key, type: 'boolean', value: booleanValue };
+    }
+    if (stringValue !== undefined) {
+        return { key, type: 'string', value: stringValue };
+    }
+    return undefined;
+};
+const setEntry = (adapter, entry) => {
+    if (entry.type === 'buffer') {
+        adapter.set(entry.key, new Uint8Array(entry.value).buffer);
+    }
+    else {
+        adapter.set(entry.key, entry.value);
+    }
+};
+const getStorageBlacklist = (config, storageId) => {
+    if (!config) {
+        return undefined;
+    }
+    if (config instanceof RegExp) {
+        return config;
+    }
+    return config[storageId];
+};
+const createStorageBlacklistMatcher = (config, storageId) => {
+    if (!(config instanceof RegExp)) {
+        return undefined;
+    }
+    return (key) => {
+        config.lastIndex = 0;
+        return config.test(`${storageId}:${key}`);
+    };
+};
+export const createMMKVStorageAdapter = ({ adapterId = 'mmkv', adapterName = 'MMKV', storages, blacklist, }) => {
+    const normalizedStorages = normalizeStorages(storages);
+    const storageNodes = Object.entries(normalizedStorages).map(([storageId, storage]) => {
+        const mmkv = getMMKVAdapter(storage);
+        return {
+            id: storageId,
+            name: storageId,
+            blacklist: getStorageBlacklist(blacklist, storageId),
+            shouldFilterKey: createStorageBlacklistMatcher(blacklist, storageId),
+            capabilities: {
+                supportedTypes: DEFAULT_SUPPORTED_TYPES,
+            },
+            storage: {
+                kind: 'sync',
+                getAllKeys: () => mmkv.getAllKeys(),
+                get: (key) => getEntry(mmkv, key),
+                set: (entry) => setEntry(mmkv, entry),
+                delete: (key) => mmkv.delete(key),
+                clear: mmkv.clear,
+                subscribe: (callback) => mmkv.addOnValueChangedListener(callback),
+            },
+        };
+    });
+    return {
+        id: adapterId,
+        name: adapterName,
+        storages: storageNodes,
+    };
+};

package/dist/react-native/src/react-native/adapters/secure-storage.d.ts

@@ -0,0 +1,18 @@
+import type { StorageAdapter } from '../../shared/types';
+export type SecureStorageLike = {
+    getItemAsync: (key: string) => Promise<string | null>;
+    setItemAsync: (key: string, value: string) => Promise<void>;
+    deleteItemAsync: (key: string) => Promise<void>;
+};
+type KeySource = string[] | (() => Promise<string[]>);
+export type CreateExpoSecureStorageAdapterOptions = {
+    storage: SecureStorageLike;
+    keys: KeySource;
+    adapterId?: string;
+    adapterName?: string;
+    storageId?: string;
+    storageName?: string;
+    blacklist?: RegExp;
+};
+export declare const createExpoSecureStorageAdapter: ({ storage, keys, adapterId, adapterName, storageId, storageName, blacklist, }: CreateExpoSecureStorageAdapterOptions) => StorageAdapter;
+export {};

package/dist/react-native/src/react-native/adapters/secure-storage.js

@@ -0,0 +1,47 @@
+const resolveKeys = async (source) => {
+    if (Array.isArray(source)) {
+        return source;
+    }
+    return source();
+};
+export const createExpoSecureStorageAdapter = ({ storage, keys, adapterId = 'expo-secure-store', adapterName = 'Expo SecureStore', storageId = 'default', storageName = 'Default Secure Storage', blacklist, }) => {
+    const storageNode = {
+        id: storageId,
+        name: storageName,
+        blacklist,
+        capabilities: {
+            supportedTypes: ['string'],
+        },
+        storage: {
+            kind: 'async',
+            getAllKeys: () => resolveKeys(keys),
+            get: async (key) => {
+                const value = await storage.getItemAsync(key);
+                if (value === null) {
+                    return undefined;
+                }
+                return {
+                    key,
+                    type: 'string',
+                    value,
+                };
+            },
+            set: async (entry) => {
+                if (entry.type !== 'string') {
+                    throw new Error('Expo SecureStore adapter supports only string values.');
+                }
+                await storage.setItemAsync(entry.key, entry.value);
+            },
+            delete: (key) => storage.deleteItemAsync(key),
+            clear: async () => {
+                const storageKeys = await resolveKeys(keys);
+                await Promise.all(storageKeys.map((key) => storage.deleteItemAsync(key)));
+            },
+        },
+    };
+    return {
+        id: adapterId,
+        name: adapterName,
+        storages: [storageNode],
+    };
+};

package/dist/react-native/src/react-native/entry-preview-pagination.d.ts

@@ -0,0 +1,7 @@
+import type { StorageListEntryPreviewsResponseEvent, StorageRequestErrorEvent } from '../shared/messaging';
+import type { StorageView } from './storage-view';
+export declare const MAX_ENTRY_PREVIEW_PAGE_SIZE = 100;
+export declare const ENTRY_PREVIEW_READ_CONCURRENCY = 4;
+type PaginationResult = StorageListEntryPreviewsResponseEvent | StorageRequestErrorEvent;
+export declare const handleListEntryPreviewsRequest: (views: readonly StorageView[], payload: unknown) => Promise<PaginationResult>;
+export {};

package/dist/react-native/src/react-native/entry-preview-pagination.js

@@ -0,0 +1,194 @@
+import { toStorageEntryPreview } from '../shared/entry-preview';
+export const MAX_ENTRY_PREVIEW_PAGE_SIZE = 100;
+export const ENTRY_PREVIEW_READ_CONCURRENCY = 4;
+const getRequestId = (payload) => typeof payload === 'object' &&
+    payload != null &&
+    !Array.isArray(payload) &&
+    typeof payload.requestId === 'string'
+    ? payload.requestId
+    : '';
+const isTarget = (value) => typeof value === 'object' &&
+    value != null &&
+    !Array.isArray(value) &&
+    typeof value.adapterId === 'string' &&
+    value.adapterId.trim().length > 0 &&
+    typeof value.storageId === 'string' &&
+    value.storageId.trim().length > 0;
+const normalizeSearch = (search) => (search ?? '').trim().toLowerCase();
+const validateRequest = (payload) => {
+    if (typeof payload !== 'object' ||
+        payload == null ||
+        Array.isArray(payload) ||
+        payload.type !== 'list-entry-previews' ||
+        typeof payload.requestId !== 'string' ||
+        payload.requestId.trim().length === 0 ||
+        !isTarget(payload.target) ||
+        (payload.search !== undefined &&
+            typeof payload.search !== 'string') ||
+        (payload.cursor !== undefined &&
+            typeof payload.cursor !== 'string') ||
+        !Number.isFinite(payload.limit) ||
+        !Number.isInteger(payload.limit) ||
+        payload.limit < 1) {
+        return undefined;
+    }
+    const keySortDirection = payload.keySortDirection;
+    if (keySortDirection !== undefined &&
+        keySortDirection !== 'ascending' &&
+        keySortDirection !== 'descending') {
+        return undefined;
+    }
+    const request = payload;
+    return {
+        ...request,
+        search: normalizeSearch(request.search),
+        keySortDirection: keySortDirection ?? 'ascending',
+        limit: Math.min(request.limit, MAX_ENTRY_PREVIEW_PAGE_SIZE),
+    };
+};
+// Cursor contents are intentionally private to the device protocol. Callers only
+// receive and return this opaque token; its representation may change freely.
+const encodeCursor = (cursor) => btoa(encodeURIComponent(JSON.stringify(cursor)));
+const decodeCursor = (value) => {
+    try {
+        const parsed = JSON.parse(decodeURIComponent(atob(value)));
+        if (typeof parsed !== 'object' ||
+            parsed == null ||
+            Array.isArray(parsed) ||
+            parsed.version !== 1 ||
+            !isTarget(parsed.target) ||
+            typeof parsed.search !== 'string' ||
+            (parsed.keySortDirection !== 'ascending' &&
+                parsed.keySortDirection !== 'descending') ||
+            typeof parsed.boundaryKey !== 'string' ||
+            (parsed.direction !== 'next' &&
+                parsed.direction !== 'previous')) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+};
+const isSameTarget = (left, right) => left.adapterId === right.adapterId && left.storageId === right.storageId;
+const compareKeys = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+const readPreviews = async (view, keys) => {
+    const previews = new Array(keys.length);
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < keys.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            const entry = await view.get(keys[index]);
+            if (entry) {
+                previews[index] = toStorageEntryPreview(entry);
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(ENTRY_PREVIEW_READ_CONCURRENCY, keys.length) }, worker));
+    return previews.filter((preview) => preview != null);
+};
+export const handleListEntryPreviewsRequest = async (views, payload) => {
+    const requestId = getRequestId(payload);
+    const request = validateRequest(payload);
+    if (!request) {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'INVALID_REQUEST',
+            message: 'Entry preview requests require a valid target, request ID, and positive integer limit.',
+        };
+    }
+    const view = views.find((candidate) => isSameTarget(candidate.target, request.target));
+    if (!view) {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'TARGET_NOT_FOUND',
+            message: 'The requested storage target was not found.',
+        };
+    }
+    let cursor;
+    if (request.cursor !== undefined) {
+        cursor = decodeCursor(request.cursor);
+        if (!cursor ||
+            !isSameTarget(cursor.target, request.target) ||
+            cursor.search !== request.search ||
+            cursor.keySortDirection !== request.keySortDirection) {
+            return {
+                type: 'storage-request-error',
+                requestId,
+                code: 'INVALID_CURSOR',
+                message: 'The entry preview cursor is invalid or belongs to a different query.',
+                resetPagination: true,
+            };
+        }
+    }
+    try {
+        const keys = (await view.getAllKeys())
+            .filter((key) => key.toLowerCase().includes(request.search))
+            .sort(compareKeys);
+        if (request.keySortDirection === 'descending') {
+            keys.reverse();
+        }
+        let start = 0;
+        if (cursor) {
+            const boundaryIndex = keys.indexOf(cursor.boundaryKey);
+            if (boundaryIndex === -1) {
+                return {
+                    type: 'storage-request-error',
+                    requestId,
+                    code: 'INVALID_CURSOR',
+                    message: 'The entry preview cursor is stale after storage changes.',
+                    resetPagination: true,
+                };
+            }
+            start =
+                cursor.direction === 'next'
+                    ? boundaryIndex + 1
+                    : Math.max(0, boundaryIndex - request.limit);
+        }
+        const pageKeys = keys.slice(start, start + request.limit);
+        const items = await readPreviews(view, pageKeys);
+        const end = start + pageKeys.length;
+        const cursorBase = {
+            version: 1,
+            target: request.target,
+            search: request.search,
+            keySortDirection: request.keySortDirection,
+        };
+        return {
+            type: 'entry-previews',
+            requestId,
+            target: request.target,
+            items,
+            ...(end < keys.length && pageKeys.length > 0
+                ? {
+                    nextCursor: encodeCursor({
+                        ...cursorBase,
+                        boundaryKey: pageKeys.at(-1),
+                        direction: 'next',
+                    }),
+                }
+                : {}),
+            ...(start > 0 && pageKeys.length > 0
+                ? {
+                    previousCursor: encodeCursor({
+                        ...cursorBase,
+                        boundaryKey: pageKeys[0],
+                        direction: 'previous',
+                    }),
+                }
+                : {}),
+        };
+    }
+    catch {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'READ_FAILED',
+            message: 'Failed to read entry previews from the requested storage.',
+        };
+    }
+};

package/dist/react-native/src/react-native/export-snapshot.d.ts

@@ -0,0 +1,5 @@
+import type { StorageExportSnapshotResponseEvent, StorageRequestErrorEvent } from '../shared/messaging';
+import type { StorageView } from './storage-view';
+type ExportSnapshotResult = StorageExportSnapshotResponseEvent | StorageRequestErrorEvent;
+export declare const handleExportSnapshotRequest: (views: readonly StorageView[], payload: unknown) => Promise<ExportSnapshotResult>;
+export {};

package/dist/react-native/src/react-native/export-snapshot.js

@@ -0,0 +1,66 @@
+import { buildSnapshot } from '../shared/snapshot';
+const getRequestId = (payload) => typeof payload === 'object' &&
+    payload != null &&
+    !Array.isArray(payload) &&
+    typeof payload.requestId === 'string'
+    ? payload.requestId
+    : '';
+const isTarget = (value) => typeof value === 'object' &&
+    value != null &&
+    !Array.isArray(value) &&
+    typeof value.adapterId === 'string' &&
+    value.adapterId.trim().length > 0 &&
+    typeof value.storageId === 'string' &&
+    value.storageId.trim().length > 0;
+const isSameTarget = (left, right) => left.adapterId === right.adapterId && left.storageId === right.storageId;
+const validateRequest = (payload) => typeof payload === 'object' &&
+    payload != null &&
+    !Array.isArray(payload) &&
+    payload.type === 'export-snapshot' &&
+    typeof payload.requestId === 'string' &&
+    payload.requestId.trim().length > 0 &&
+    isTarget(payload.target);
+export const handleExportSnapshotRequest = async (views, payload) => {
+    const requestId = getRequestId(payload);
+    if (!validateRequest(payload)) {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'INVALID_REQUEST',
+            message: 'Export requests require a valid target and request ID.',
+        };
+    }
+    const view = views.find((candidate) => isSameTarget(candidate.target, payload.target));
+    if (!view) {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'TARGET_NOT_FOUND',
+            message: 'The requested storage target was not found.',
+        };
+    }
+    try {
+        // getAllEntries applies the storage view's blacklist before reading values.
+        const entries = await view.getAllEntries();
+        return {
+            type: 'export-snapshot-result',
+            requestId,
+            target: view.target,
+            snapshot: buildSnapshot({
+                target: view.target,
+                adapterName: view.adapterName,
+                storageName: view.storageName,
+                capabilities: view.capabilities,
+                entries,
+            }),
+        };
+    }
+    catch {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'READ_FAILED',
+            message: 'Failed to export the requested storage.',
+        };
+    }
+};

package/dist/react-native/src/react-native/full-entry-request.d.ts

@@ -0,0 +1,5 @@
+import type { StorageGetEntryResponseEvent, StorageRequestErrorEvent } from '../shared/messaging';
+import type { StorageView } from './storage-view';
+type FullEntryResult = StorageGetEntryResponseEvent | StorageRequestErrorEvent;
+export declare const handleFullEntryRequest: (views: readonly StorageView[], payload: unknown) => Promise<FullEntryResult>;
+export {};

package/dist/react-native/src/react-native/full-entry-request.js

@@ -0,0 +1,68 @@
+const getRequestId = (payload) => typeof payload === 'object' &&
+    payload != null &&
+    !Array.isArray(payload) &&
+    typeof payload.requestId === 'string'
+    ? payload.requestId
+    : '';
+const isTarget = (value) => typeof value === 'object' &&
+    value != null &&
+    !Array.isArray(value) &&
+    typeof value.adapterId === 'string' &&
+    value.adapterId.trim().length > 0 &&
+    typeof value.storageId === 'string' &&
+    value.storageId.trim().length > 0;
+const isSameTarget = (left, right) => left.adapterId === right.adapterId && left.storageId === right.storageId;
+const validateRequest = (payload) => typeof payload === 'object' &&
+    payload != null &&
+    !Array.isArray(payload) &&
+    payload.type === 'get-entry' &&
+    typeof payload.requestId === 'string' &&
+    payload.requestId.trim().length > 0 &&
+    isTarget(payload.target) &&
+    typeof payload.key === 'string';
+export const handleFullEntryRequest = async (views, payload) => {
+    const requestId = getRequestId(payload);
+    if (!validateRequest(payload)) {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'INVALID_REQUEST',
+            message: 'Full entry requests require a valid target, request ID, and string key.',
+        };
+    }
+    const view = views.find((candidate) => isSameTarget(candidate.target, payload.target));
+    if (!view) {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'TARGET_NOT_FOUND',
+            message: 'The requested storage target was not found.',
+        };
+    }
+    try {
+        // StorageView applies the same blacklist policy used by preview requests.
+        const entry = await view.get(payload.key);
+        if (!entry) {
+            return {
+                type: 'storage-request-error',
+                requestId,
+                code: 'ENTRY_NOT_FOUND',
+                message: 'The requested storage entry was not found.',
+            };
+        }
+        return {
+            type: 'entry',
+            requestId,
+            target: view.target,
+            entry,
+        };
+    }
+    catch {
+        return {
+            type: 'storage-request-error',
+            requestId,
+            code: 'READ_FAILED',
+            message: 'Failed to read the requested storage entry.',
+        };
+    }
+};