@effuse/store 1.0.2 → 1.0.3

package/src/handlers/operations.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect, vi } from 'vitest';
+import { signal } from '@effuse/core';
+import {
+	setValue,
+	resetState,
+	batchUpdates,
+	updateState,
+	getSnapshot,
+} from './operations.js';
+import type { StoreHandlerDeps, StoreInternals } from './types.js';
+import { createCancellationScope } from '../actions/cancellation.js';
+import { createAtomicState } from '../core/state.js';
+import { createMiddlewareManager } from '../middleware/index.js';
+import { createMemoryAdapter } from '../persistence/adapters.js';
+
+const createMockDeps = (
+	initialState: Record<string, unknown> = {}
+): StoreHandlerDeps => {
+	const signalMap = new Map<string, ReturnType<typeof signal>>();
+	for (const [key, value] of Object.entries(initialState)) {
+		signalMap.set(key, signal(value));
+	}
+
+	const internals: StoreInternals = {
+		signalMap,
+		initialState: { ...initialState },
+		actions: {},
+		subscribers: new Set(),
+		keySubscribers: new Map(),
+		computedSelectors: new Map(),
+		isBatching: false,
+		cancellationScope: createCancellationScope(),
+		pendingActions: new Map(),
+	};
+
+	return {
+		internals,
+		atomicState: createAtomicState(initialState),
+		middlewareManager: createMiddlewareManager(),
+		config: {
+			name: 'testStore',
+			shouldPersist: false,
+			storageKey: 'test_store',
+			enableDevtools: false,
+			adapter: createMemoryAdapter(),
+		},
+	};
+};
+
+describe('operations handlers', () => {
+	describe('setValue', () => {
+		it('should set a value in the signal map', () => {
+			const deps = createMockDeps({ count: 0 });
+			setValue(deps, { prop: 'count', value: 5 });
+			expect(deps.internals.signalMap.get('count')?.value).toBe(5);
+		});
+
+		it('should create new signal for non-existent property', () => {
+			const deps = createMockDeps({});
+			setValue(deps, { prop: 'newProp', value: 'hello' });
+			expect(deps.internals.signalMap.get('newProp')?.value).toBe('hello');
+		});
+
+		it('should notify subscribers after value change', () => {
+			const deps = createMockDeps({ count: 0 });
+			const subscriber = vi.fn();
+			deps.internals.subscribers.add(subscriber);
+			setValue(deps, { prop: 'count', value: 10 });
+			expect(subscriber).toHaveBeenCalled();
+		});
+
+		it('should notify key subscribers with new value', () => {
+			const deps = createMockDeps({ count: 0 });
+			const keySubscriber = vi.fn();
+			deps.internals.keySubscribers.set('count', new Set([keySubscriber]));
+			setValue(deps, { prop: 'count', value: 42 });
+			expect(keySubscriber).toHaveBeenCalledWith(42);
+		});
+
+		it('should NOT notify subscribers when batching', () => {
+			const deps = createMockDeps({ count: 0 });
+			deps.internals.isBatching = true;
+			const subscriber = vi.fn();
+			deps.internals.subscribers.add(subscriber);
+			setValue(deps, { prop: 'count', value: 5 });
+			expect(subscriber).not.toHaveBeenCalled();
+		});
+
+		it('should handle setting undefined value', () => {
+			const deps = createMockDeps({ count: 0 });
+			setValue(deps, { prop: 'count', value: undefined });
+			expect(deps.internals.signalMap.get('count')?.value).toBe(undefined);
+		});
+
+		it('should handle setting null value', () => {
+			const deps = createMockDeps({ name: 'test' });
+			setValue(deps, { prop: 'name', value: null });
+			expect(deps.internals.signalMap.get('name')?.value).toBe(null);
+		});
+
+		it('should handle complex object values', () => {
+			const deps = createMockDeps({ user: null });
+			const complexValue = { id: 1, nested: { a: [1, 2, 3] } };
+			setValue(deps, { prop: 'user', value: complexValue });
+			expect(deps.internals.signalMap.get('user')?.value).toEqual(complexValue);
+		});
+	});
+
+	describe('resetState', () => {
+		it('should reset all values to initial state', () => {
+			const deps = createMockDeps({ count: 0, name: 'initial' });
+			setValue(deps, { prop: 'count', value: 100 });
+			setValue(deps, { prop: 'name', value: 'changed' });
+			resetState(deps);
+			expect(deps.internals.signalMap.get('count')?.value).toBe(0);
+			expect(deps.internals.signalMap.get('name')?.value).toBe('initial');
+		});
+
+		it('should notify subscribers after reset', () => {
+			const deps = createMockDeps({ count: 0 });
+			const subscriber = vi.fn();
+			deps.internals.subscribers.add(subscriber);
+			setValue(deps, { prop: 'count', value: 50 });
+			subscriber.mockClear();
+			resetState(deps);
+			expect(subscriber).toHaveBeenCalled();
+		});
+
+		it('should handle empty initial state', () => {
+			const deps = createMockDeps({});
+			expect(() => resetState(deps)).not.toThrow();
+		});
+	});
+
+	describe('batchUpdates', () => {
+		it('should batch multiple updates without intermediate notifications', () => {
+			const deps = createMockDeps({ a: 0, b: 0 });
+			const subscriber = vi.fn();
+			deps.internals.subscribers.add(subscriber);
+			batchUpdates(deps, () => {
+				setValue(deps, { prop: 'a', value: 1 });
+				setValue(deps, { prop: 'b', value: 2 });
+			});
+			expect(subscriber).toHaveBeenCalledTimes(1);
+		});
+
+		it('should execute all updates within batch', () => {
+			const deps = createMockDeps({ a: 0, b: 0, c: 0 });
+			batchUpdates(deps, () => {
+				setValue(deps, { prop: 'a', value: 10 });
+				setValue(deps, { prop: 'b', value: 20 });
+				setValue(deps, { prop: 'c', value: 30 });
+			});
+			expect(deps.internals.signalMap.get('a')?.value).toBe(10);
+			expect(deps.internals.signalMap.get('b')?.value).toBe(20);
+			expect(deps.internals.signalMap.get('c')?.value).toBe(30);
+		});
+
+		it('should reset batching flag even if updates throw', () => {
+			const deps = createMockDeps({ count: 0 });
+			try {
+				batchUpdates(deps, () => {
+					setValue(deps, { prop: 'count', value: 5 });
+					throw new Error('test error');
+				});
+			} catch {
+				// Expected
+			}
+			expect(deps.internals.isBatching).toBe(false);
+		});
+
+		it('should handle nested batches correctly', () => {
+			const deps = createMockDeps({ a: 0 });
+			const subscriber = vi.fn();
+			deps.internals.subscribers.add(subscriber);
+			batchUpdates(deps, () => {
+				setValue(deps, { prop: 'a', value: 1 });
+				batchUpdates(deps, () => {
+					setValue(deps, { prop: 'a', value: 2 });
+				});
+			});
+			expect(deps.internals.signalMap.get('a')?.value).toBe(2);
+		});
+	});
+
+	describe('updateState', () => {
+		it('should update state via draft function', () => {
+			const deps = createMockDeps({ count: 0, items: [] });
+			updateState(deps, {
+				updater: (draft) => {
+					draft.count = 10;
+				},
+			});
+			expect(deps.internals.signalMap.get('count')?.value).toBe(10);
+		});
+
+		it('should handle multiple property updates', () => {
+			const deps = createMockDeps({ a: 1, b: 2, c: 3 });
+			updateState(deps, {
+				updater: (draft) => {
+					draft.a = 100;
+					draft.b = 200;
+					draft.c = 300;
+				},
+			});
+			expect(deps.internals.signalMap.get('a')?.value).toBe(100);
+			expect(deps.internals.signalMap.get('b')?.value).toBe(200);
+			expect(deps.internals.signalMap.get('c')?.value).toBe(300);
+		});
+	});
+
+	describe('getSnapshot', () => {
+		it('should return snapshot of current state', () => {
+			const deps = createMockDeps({ count: 5, name: 'test' });
+			const snapshot = getSnapshot(deps.internals.signalMap);
+			expect(snapshot).toEqual({ count: 5, name: 'test' });
+		});
+
+		it('should return empty object for empty state', () => {
+			const deps = createMockDeps({});
+			const snapshot = getSnapshot(deps.internals.signalMap);
+			expect(snapshot).toEqual({});
+		});
+
+		it('should return copy not reference', () => {
+			const deps = createMockDeps({ items: [1, 2, 3] });
+			const snapshot1 = getSnapshot(deps.internals.signalMap);
+			const snapshot2 = getSnapshot(deps.internals.signalMap);
+			expect(snapshot1).not.toBe(snapshot2);
+		});
+	});
+});

package/src/handlers/operations.ts

@@ -0,0 +1,214 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { signal, type Signal } from '@effuse/core';
+import type {
+	StoreHandlerDeps,
+	SetValueInput,
+	UpdateStateInput,
+} from './types.js';
+import { runAdapter } from '../persistence/index.js';
+
+const getSnapshot = (
+	signalMap: Map<string, Signal<unknown>>
+): Record<string, unknown> => {
+	const snapshot: Record<string, unknown> = {};
+	for (const [key, sig] of signalMap) {
+		snapshot[key] = sig.value;
+	}
+	return snapshot;
+};
+
+const notifyAll = (deps: StoreHandlerDeps): void => {
+	if (deps.internals.isBatching) return;
+	for (const callback of deps.internals.subscribers) callback();
+};
+
+const notifyKey = (
+	deps: StoreHandlerDeps,
+	key: string,
+	value: unknown
+): void => {
+	if (deps.internals.isBatching) return;
+	const subs = deps.internals.keySubscribers.get(key);
+	if (subs) for (const cb of subs) cb(value);
+};
+
+const persist = (deps: StoreHandlerDeps): void => {
+	if (!deps.config.shouldPersist) return;
+	const snapshot = getSnapshot(deps.internals.signalMap);
+	runAdapter.setItem(
+		deps.config.adapter,
+		deps.config.storageKey,
+		JSON.stringify(snapshot)
+	);
+};
+
+const updateComputed = (deps: StoreHandlerDeps): void => {
+	const snapshot = getSnapshot(deps.internals.signalMap);
+	for (const [selector, sig] of deps.internals.computedSelectors) {
+		const newValue = selector(snapshot);
+		if (sig.value !== newValue) sig.value = newValue;
+	}
+};
+
+const logDevtools = (
+	deps: StoreHandlerDeps,
+	actionType: string,
+	payload: unknown,
+	prevState: Record<string, unknown>,
+	nextState: Record<string, unknown>
+): void => {
+	if (!deps.config.enableDevtools) return;
+	const time = new Date().toLocaleTimeString();
+	// eslint-disable-next-line no-console
+	console.groupCollapsed(
+		`%caction %c${deps.config.name}/${actionType} %c@ ${time}`,
+		'color: gray; font-weight: lighter;',
+		'color: inherit; font-weight: bold;',
+		'color: gray; font-weight: lighter;'
+	);
+	// eslint-disable-next-line no-console
+	console.log('%cprev state', 'color: #9E9E9E; font-weight: bold;', prevState);
+	// eslint-disable-next-line no-console
+	console.log('%caction', 'color: #03A9F4; font-weight: bold;', {
+		type: actionType,
+		payload,
+	});
+	// eslint-disable-next-line no-console
+	console.log('%cnext state', 'color: #4CAF50; font-weight: bold;', nextState);
+	// eslint-disable-next-line no-console
+	console.groupEnd();
+};
+
+export const setValue = (
+	deps: StoreHandlerDeps,
+	input: SetValueInput
+): boolean => {
+	const { prop, value } = input;
+	const { internals, atomicState, middlewareManager, config } = deps;
+
+	if (!internals.signalMap.has(prop)) {
+		internals.signalMap.set(prop, signal(value));
+	}
+
+	const sig = internals.signalMap.get(prop);
+	if (!sig) return false;
+
+	const prevState = config.enableDevtools
+		? getSnapshot(internals.signalMap)
+		: {};
+
+	const newState = middlewareManager.execute(
+		{ ...atomicState.get(), [prop]: value },
+		`set:${prop}`,
+		[value]
+	);
+
+	sig.value = newState[prop];
+	atomicState.update((s) => ({ ...s, [prop]: newState[prop] }));
+
+	logDevtools(deps, `set:${prop}`, value, prevState, {
+		...atomicState.get(),
+		[prop]: newState[prop],
+	});
+
+	notifyAll(deps);
+	notifyKey(deps, prop, newState[prop]);
+	persist(deps);
+	updateComputed(deps);
+
+	return true;
+};
+
+export const resetState = (deps: StoreHandlerDeps): void => {
+	const { internals, atomicState, config } = deps;
+	const prevState = config.enableDevtools
+		? getSnapshot(internals.signalMap)
+		: {};
+
+	for (const [key, value] of Object.entries(internals.initialState)) {
+		const sig = internals.signalMap.get(key);
+		if (sig) sig.value = value;
+	}
+	atomicState.set({ ...internals.initialState });
+
+	logDevtools(deps, 'reset', null, prevState, { ...internals.initialState });
+
+	notifyAll(deps);
+	persist(deps);
+	updateComputed(deps);
+};
+
+export const batchUpdates = (
+	deps: StoreHandlerDeps,
+	updates: () => void
+): void => {
+	deps.internals.isBatching = true;
+	try {
+		updates();
+	} finally {
+		deps.internals.isBatching = false;
+	}
+	notifyAll(deps);
+	persist(deps);
+	updateComputed(deps);
+};
+
+export const updateState = (
+	deps: StoreHandlerDeps,
+	input: UpdateStateInput
+): void => {
+	const { internals, atomicState, config } = deps;
+	const prevState = config.enableDevtools
+		? getSnapshot(internals.signalMap)
+		: {};
+
+	const draft = { ...getSnapshot(internals.signalMap) };
+	input.updater(draft);
+
+	internals.isBatching = true;
+	for (const [key, val] of Object.entries(draft)) {
+		const sig = internals.signalMap.get(key);
+		if (sig && sig.value !== val) {
+			sig.value = val;
+			atomicState.update((s) => ({ ...s, [key]: val }));
+		}
+	}
+	internals.isBatching = false;
+
+	logDevtools(
+		deps,
+		'update',
+		null,
+		prevState,
+		getSnapshot(internals.signalMap)
+	);
+
+	notifyAll(deps);
+	persist(deps);
+	updateComputed(deps);
+};
+
+export { getSnapshot };

package/src/handlers/persistence.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { Option } from 'effect';
+import {
+	getItem,
+	setItem,
+	removeItem,
+	hasItem,
+	clearStorage,
+	getStorageKeys,
+	getStorageSize,
+} from './persistence.js';
+import type { StorageHandlerDeps } from './persistence.js';
+
+const createMockDeps = (
+	initial: Record<string, string> = {}
+): StorageHandlerDeps => {
+	const storage = new Map<string, string>(Object.entries(initial));
+	return { storage };
+};
+
+describe('persistence handlers', () => {
+	describe('getItem', () => {
+		it('should return Some for existing key', () => {
+			const deps = createMockDeps({ key1: 'value1' });
+			const result = getItem(deps, { key: 'key1' });
+			expect(Option.isSome(result)).toBe(true);
+			expect(Option.getOrNull(result)).toBe('value1');
+		});
+
+		it('should return None for non-existent key', () => {
+			const deps = createMockDeps({});
+			const result = getItem(deps, { key: 'missing' });
+			expect(Option.isNone(result)).toBe(true);
+		});
+
+		it('should return empty string value correctly', () => {
+			const deps = createMockDeps({ empty: '' });
+			const result = getItem(deps, { key: 'empty' });
+			expect(Option.isSome(result)).toBe(true);
+			expect(Option.getOrNull(result)).toBe('');
+		});
+
+		it('should handle special characters in key', () => {
+			const deps = createMockDeps({ 'key.with.dots': 'value' });
+			const result = getItem(deps, { key: 'key.with.dots' });
+			expect(Option.getOrNull(result)).toBe('value');
+		});
+
+		it('should handle unicode key', () => {
+			const deps = createMockDeps({ 日本語: 'japanese' });
+			const result = getItem(deps, { key: '日本語' });
+			expect(Option.getOrNull(result)).toBe('japanese');
+		});
+	});
+
+	describe('setItem', () => {
+		it('should set value for new key', () => {
+			const deps = createMockDeps({});
+			setItem(deps, { key: 'newKey', value: 'newValue' });
+			expect(deps.storage.get('newKey')).toBe('newValue');
+		});
+
+		it('should overwrite existing value', () => {
+			const deps = createMockDeps({ key1: 'oldValue' });
+			setItem(deps, { key: 'key1', value: 'newValue' });
+			expect(deps.storage.get('key1')).toBe('newValue');
+		});
+
+		it('should handle empty string value', () => {
+			const deps = createMockDeps({});
+			setItem(deps, { key: 'key1', value: '' });
+			expect(deps.storage.get('key1')).toBe('');
+		});
+
+		it('should handle very long values', () => {
+			const deps = createMockDeps({});
+			const longValue = 'x'.repeat(10000);
+			setItem(deps, { key: 'long', value: longValue });
+			expect(deps.storage.get('long')).toBe(longValue);
+		});
+
+		it('should handle JSON stringified objects', () => {
+			const deps = createMockDeps({});
+			const jsonValue = JSON.stringify({ a: 1, b: [1, 2, 3] });
+			setItem(deps, { key: 'json', value: jsonValue });
+			expect(JSON.parse(deps.storage.get('json')!)).toEqual({
+				a: 1,
+				b: [1, 2, 3],
+			});
+		});
+	});
+
+	describe('removeItem', () => {
+		it('should remove existing key and return true', () => {
+			const deps = createMockDeps({ key1: 'value1' });
+			const result = removeItem(deps, { key: 'key1' });
+			expect(result).toBe(true);
+			expect(deps.storage.has('key1')).toBe(false);
+		});
+
+		it('should return false for non-existent key', () => {
+			const deps = createMockDeps({});
+			const result = removeItem(deps, { key: 'missing' });
+			expect(result).toBe(false);
+		});
+
+		it('should not affect other keys', () => {
+			const deps = createMockDeps({ a: '1', b: '2', c: '3' });
+			removeItem(deps, { key: 'b' });
+			expect(deps.storage.get('a')).toBe('1');
+			expect(deps.storage.get('c')).toBe('3');
+		});
+	});
+
+	describe('hasItem', () => {
+		it('should return true for existing key', () => {
+			const deps = createMockDeps({ key1: 'value1' });
+			expect(hasItem(deps, { key: 'key1' })).toBe(true);
+		});
+
+		it('should return false for non-existent key', () => {
+			const deps = createMockDeps({});
+			expect(hasItem(deps, { key: 'missing' })).toBe(false);
+		});
+
+		it('should return true for key with empty value', () => {
+			const deps = createMockDeps({ empty: '' });
+			expect(hasItem(deps, { key: 'empty' })).toBe(true);
+		});
+	});
+
+	describe('clearStorage', () => {
+		it('should remove all items', () => {
+			const deps = createMockDeps({ a: '1', b: '2', c: '3' });
+			clearStorage(deps);
+			expect(deps.storage.size).toBe(0);
+		});
+
+		it('should handle empty storage', () => {
+			const deps = createMockDeps({});
+			expect(() => clearStorage(deps)).not.toThrow();
+		});
+	});
+
+	describe('getStorageKeys', () => {
+		it('should return all keys', () => {
+			const deps = createMockDeps({ a: '1', b: '2', c: '3' });
+			const keys = getStorageKeys(deps);
+			expect(keys).toHaveLength(3);
+			expect(keys).toContain('a');
+			expect(keys).toContain('b');
+			expect(keys).toContain('c');
+		});
+
+		it('should return empty array for empty storage', () => {
+			const deps = createMockDeps({});
+			expect(getStorageKeys(deps)).toEqual([]);
+		});
+	});
+
+	describe('getStorageSize', () => {
+		it('should return correct size', () => {
+			const deps = createMockDeps({ a: '1', b: '2', c: '3' });
+			expect(getStorageSize(deps)).toBe(3);
+		});
+
+		it('should return 0 for empty storage', () => {
+			const deps = createMockDeps({});
+			expect(getStorageSize(deps)).toBe(0);
+		});
+
+		it('should update after operations', () => {
+			const deps = createMockDeps({});
+			setItem(deps, { key: 'a', value: '1' });
+			expect(getStorageSize(deps)).toBe(1);
+			setItem(deps, { key: 'b', value: '2' });
+			expect(getStorageSize(deps)).toBe(2);
+			removeItem(deps, { key: 'a' });
+			expect(getStorageSize(deps)).toBe(1);
+		});
+	});
+});

package/src/handlers/persistence.ts

@@ -0,0 +1,82 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Option } from 'effect';
+
+export interface StorageHandlerDeps {
+	storage: Map<string, string>;
+}
+
+export interface StorageGetInput {
+	key: string;
+}
+
+export interface StorageSetInput {
+	key: string;
+	value: string;
+}
+
+export interface StorageRemoveInput {
+	key: string;
+}
+
+export const getItem = (
+	deps: StorageHandlerDeps,
+	input: StorageGetInput
+): Option.Option<string> => {
+	return Option.fromNullable(deps.storage.get(input.key));
+};
+
+export const setItem = (
+	deps: StorageHandlerDeps,
+	input: StorageSetInput
+): void => {
+	deps.storage.set(input.key, input.value);
+};
+
+export const removeItem = (
+	deps: StorageHandlerDeps,
+	input: StorageRemoveInput
+): boolean => {
+	return deps.storage.delete(input.key);
+};
+
+export const hasItem = (
+	deps: StorageHandlerDeps,
+	input: StorageGetInput
+): boolean => {
+	return deps.storage.has(input.key);
+};
+
+export const clearStorage = (deps: StorageHandlerDeps): void => {
+	deps.storage.clear();
+};
+
+export const getStorageKeys = (deps: StorageHandlerDeps): string[] => {
+	return Array.from(deps.storage.keys());
+};
+
+export const getStorageSize = (deps: StorageHandlerDeps): number => {
+	return deps.storage.size;
+};