@effuse/store 1.0.2 → 1.0.4

package/src/handlers/subscriptions.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect, vi } from 'vitest';
+import { addSubscriber, addKeySubscriber } from './subscriptions.js';
+import type { StoreInternals } from './types.js';
+import { createCancellationScope } from '../actions/cancellation.js';
+
+const createMockInternals = (): StoreInternals => ({
+	signalMap: new Map(),
+	initialState: {},
+	actions: {},
+	subscribers: new Set(),
+	keySubscribers: new Map(),
+	computedSelectors: new Map(),
+	isBatching: false,
+	cancellationScope: createCancellationScope(),
+	pendingActions: new Map(),
+});
+
+describe('subscriptions handlers', () => {
+	describe('addSubscriber', () => {
+		it('should add subscriber to the set', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			addSubscriber(internals, { callback });
+			expect(internals.subscribers.has(callback)).toBe(true);
+		});
+
+		it('should return unsubscribe function', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			const unsubscribe = addSubscriber(internals, { callback });
+			expect(typeof unsubscribe).toBe('function');
+		});
+
+		it('should remove subscriber when unsubscribe is called', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			const unsubscribe = addSubscriber(internals, { callback });
+			unsubscribe();
+			expect(internals.subscribers.has(callback)).toBe(false);
+		});
+
+		it('should handle multiple subscribers', () => {
+			const internals = createMockInternals();
+			const cb1 = vi.fn();
+			const cb2 = vi.fn();
+			const cb3 = vi.fn();
+			addSubscriber(internals, { callback: cb1 });
+			addSubscriber(internals, { callback: cb2 });
+			addSubscriber(internals, { callback: cb3 });
+			expect(internals.subscribers.size).toBe(3);
+		});
+
+		it('should handle unsubscribing multiple times without error', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			const unsubscribe = addSubscriber(internals, { callback });
+			unsubscribe();
+			unsubscribe();
+			unsubscribe();
+			expect(internals.subscribers.size).toBe(0);
+		});
+
+		it('should not affect other subscribers when one unsubscribes', () => {
+			const internals = createMockInternals();
+			const cb1 = vi.fn();
+			const cb2 = vi.fn();
+			const unsub1 = addSubscriber(internals, { callback: cb1 });
+			addSubscriber(internals, { callback: cb2 });
+			unsub1();
+			expect(internals.subscribers.has(cb1)).toBe(false);
+			expect(internals.subscribers.has(cb2)).toBe(true);
+		});
+	});
+
+	describe('addKeySubscriber', () => {
+		it('should add key subscriber for new key', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			addKeySubscriber(internals, { key: 'count', callback });
+			const subs = internals.keySubscribers.get('count');
+			expect(subs?.has(callback)).toBe(true);
+		});
+
+		it('should create subscriber set for new key', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			addKeySubscriber(internals, { key: 'newKey', callback });
+			expect(internals.keySubscribers.has('newKey')).toBe(true);
+		});
+
+		it('should add to existing subscriber set', () => {
+			const internals = createMockInternals();
+			const cb1 = vi.fn();
+			const cb2 = vi.fn();
+			addKeySubscriber(internals, { key: 'count', callback: cb1 });
+			addKeySubscriber(internals, { key: 'count', callback: cb2 });
+			const subs = internals.keySubscribers.get('count');
+			expect(subs?.size).toBe(2);
+		});
+
+		it('should return unsubscribe function', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			const unsubscribe = addKeySubscriber(internals, {
+				key: 'count',
+				callback,
+			});
+			expect(typeof unsubscribe).toBe('function');
+		});
+
+		it('should remove subscriber when unsubscribe is called', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			const unsubscribe = addKeySubscriber(internals, {
+				key: 'count',
+				callback,
+			});
+			unsubscribe();
+			const subs = internals.keySubscribers.get('count');
+			expect(subs?.has(callback)).toBe(false);
+		});
+
+		it('should handle different keys independently', () => {
+			const internals = createMockInternals();
+			const cb1 = vi.fn();
+			const cb2 = vi.fn();
+			addKeySubscriber(internals, { key: 'a', callback: cb1 });
+			addKeySubscriber(internals, { key: 'b', callback: cb2 });
+			expect(internals.keySubscribers.get('a')?.size).toBe(1);
+			expect(internals.keySubscribers.get('b')?.size).toBe(1);
+		});
+
+		it('should handle empty string key', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			addKeySubscriber(internals, { key: '', callback });
+			expect(internals.keySubscribers.has('')).toBe(true);
+		});
+
+		it('should handle special characters in key', () => {
+			const internals = createMockInternals();
+			const callback = vi.fn();
+			addKeySubscriber(internals, { key: 'user.profile.name', callback });
+			expect(internals.keySubscribers.has('user.profile.name')).toBe(true);
+		});
+	});
+});

package/src/handlers/subscriptions.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 { Predicate } from 'effect';
+import type {
+	StoreInternals,
+	SubscribeInput,
+	SubscribeKeyInput,
+} from './types.js';
+
+export const addSubscriber = (
+	internals: StoreInternals,
+	input: SubscribeInput
+): (() => void) => {
+	internals.subscribers.add(input.callback);
+	return () => {
+		internals.subscribers.delete(input.callback);
+	};
+};
+
+export const addKeySubscriber = (
+	internals: StoreInternals,
+	input: SubscribeKeyInput
+): (() => void) => {
+	let subs = internals.keySubscribers.get(input.key);
+	if (!subs) {
+		subs = new Set();
+		internals.keySubscribers.set(input.key, subs);
+	}
+	subs.add(input.callback);
+	return () => {
+		const subsSet = internals.keySubscribers.get(input.key);
+		if (Predicate.isNotNullable(subsSet)) {
+			subsSet.delete(input.callback);
+		}
+	};
+};

package/src/handlers/types.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 type { Signal } from '@effuse/core';
+import type { AtomicState } from '../core/state.js';
+import type { MiddlewareManager } from '../middleware/index.js';
+import type { StorageAdapter } from '../persistence/index.js';
+import type {
+	CancellationScope,
+	CancellationToken,
+} from '../actions/cancellation.js';
+
+export interface StoreInternals {
+	signalMap: Map<string, Signal<unknown>>;
+	initialState: Record<string, unknown>;
+	actions: Record<string, (...args: unknown[]) => unknown>;
+	subscribers: Set<() => void>;
+	keySubscribers: Map<string, Set<(value: unknown) => void>>;
+	computedSelectors: Map<
+		(s: Record<string, unknown>) => unknown,
+		Signal<unknown>
+	>;
+	isBatching: boolean;
+	cancellationScope: CancellationScope;
+	pendingActions: Map<string, CancellationToken>;
+}
+
+export interface StoreConfig {
+	name: string;
+	shouldPersist: boolean;
+	storageKey: string;
+	enableDevtools: boolean;
+	adapter: StorageAdapter;
+}
+
+export interface StoreHandlerDeps {
+	internals: StoreInternals;
+	atomicState: AtomicState<Record<string, unknown>>;
+	middlewareManager: MiddlewareManager<Record<string, unknown>>;
+	config: StoreConfig;
+}
+
+export interface SetValueInput {
+	prop: string;
+	value: unknown;
+}
+
+export interface UpdateStateInput {
+	updater: (draft: Record<string, unknown>) => void;
+}
+
+export interface SubscribeInput {
+	callback: () => void;
+}
+
+export interface SubscribeKeyInput {
+	key: string;
+	callback: (value: unknown) => void;
+}

package/src/persistence/adapters.ts

@@ -23,65 +23,95 @@
  */
 
 import { Effect, Option } from 'effect';
+import {
+	getItem,
+	setItem,
+	removeItem,
+	hasItem,
+	clearStorage,
+	getStorageKeys,
+	getStorageSize,
+	type StorageHandlerDeps,
+} from '../handlers/index.js';
 
-// Storage engine interface
 export interface StorageAdapter {
 	getItem: (key: string) => Effect.Effect<Option.Option<string>>;
 	setItem: (key: string, value: string) => Effect.Effect<void>;
 	removeItem: (key: string) => Effect.Effect<void>;
+	has: (key: string) => Effect.Effect<boolean>;
+	clear: () => Effect.Effect<void>;
+	keys: () => Effect.Effect<string[]>;
+	size: () => Effect.Effect<number>;
 }
 
-// Browser local storage adapter
-export const localStorageAdapter: StorageAdapter = {
+const createBrowserStorageAdapter = (storage: Storage): StorageAdapter => ({
 	getItem: (key) =>
 		Effect.try({
-			try: () => Option.fromNullable(localStorage.getItem(key)),
+			try: () => Option.fromNullable(storage.getItem(key)),
 			catch: () => Option.none<string>(),
 		}).pipe(Effect.catchAll(() => Effect.succeed(Option.none<string>()))),
 	setItem: (key, value) =>
 		Effect.try(() => {
-			localStorage.setItem(key, value);
+			storage.setItem(key, value);
 		}).pipe(Effect.catchAll(() => Effect.void)),
 	removeItem: (key) =>
 		Effect.try(() => {
-			localStorage.removeItem(key);
+			storage.removeItem(key);
 		}).pipe(Effect.catchAll(() => Effect.void)),
-};
-
-// Browser session storage adapter
-export const sessionStorageAdapter: StorageAdapter = {
-	getItem: (key) =>
+	has: (key) =>
 		Effect.try({
-			try: () => Option.fromNullable(sessionStorage.getItem(key)),
-			catch: () => Option.none<string>(),
-		}).pipe(Effect.catchAll(() => Effect.succeed(Option.none<string>()))),
-	setItem: (key, value) =>
-		Effect.try(() => {
-			sessionStorage.setItem(key, value);
-		}).pipe(Effect.catchAll(() => Effect.void)),
-	removeItem: (key) =>
+			try: () => storage.getItem(key) !== null,
+			catch: () => false,
+		}).pipe(Effect.catchAll(() => Effect.succeed(false))),
+	clear: () =>
 		Effect.try(() => {
-			sessionStorage.removeItem(key);
+			storage.clear();
 		}).pipe(Effect.catchAll(() => Effect.void)),
-};
+	keys: () =>
+		Effect.try({
+			try: () => Object.keys(storage),
+			catch: () => [] as string[],
+		}).pipe(Effect.catchAll(() => Effect.succeed([] as string[]))),
+	size: () =>
+		Effect.try({
+			try: () => storage.length,
+			catch: () => 0,
+		}).pipe(Effect.catchAll(() => Effect.succeed(0))),
+});
+
+export const localStorageAdapter: StorageAdapter = createBrowserStorageAdapter(
+	typeof localStorage !== 'undefined' ? localStorage : ({} as Storage)
+);
+
+export const sessionStorageAdapter: StorageAdapter =
+	createBrowserStorageAdapter(
+		typeof sessionStorage !== 'undefined' ? sessionStorage : ({} as Storage)
+	);
 
-// Build in memory storage adapter
 export const createMemoryAdapter = (): StorageAdapter => {
 	const storage = new Map<string, string>();
+	const deps: StorageHandlerDeps = { storage };
+
 	return {
-		getItem: (key) => Effect.succeed(Option.fromNullable(storage.get(key))),
+		getItem: (key) => Effect.succeed(getItem(deps, { key })),
 		setItem: (key, value) =>
 			Effect.sync(() => {
-				storage.set(key, value);
+				setItem(deps, { key, value });
 			}),
 		removeItem: (key) =>
 			Effect.sync(() => {
-				storage.delete(key);
+				removeItem(deps, { key });
+			}),
+		has: (key) => Effect.succeed(hasItem(deps, { key })),
+		clear: () =>
+			Effect.sync(() => {
+				clearStorage(deps);
 			}),
+		keys: () => Effect.succeed(getStorageKeys(deps)),
+		size: () => Effect.succeed(getStorageSize(deps)),
 	};
 };
 
-// Synchronous storage adapter bridge
 export const runAdapter = {
 	getItem: (adapter: StorageAdapter, key: string): string | null =>
 		Effect.runSync(
@@ -93,4 +123,11 @@ export const runAdapter = {
 	removeItem: (adapter: StorageAdapter, key: string): void => {
 		Effect.runSync(adapter.removeItem(key));
 	},
+	has: (adapter: StorageAdapter, key: string): boolean =>
+		Effect.runSync(adapter.has(key)),
+	clear: (adapter: StorageAdapter): void => {
+		Effect.runSync(adapter.clear());
+	},
+	keys: (adapter: StorageAdapter): string[] => Effect.runSync(adapter.keys()),
+	size: (adapter: StorageAdapter): number => Effect.runSync(adapter.size()),
 };

package/src/reactivity/streams.ts

@@ -28,7 +28,6 @@ import {
 	type CancellationToken,
 } from '../actions/cancellation.js';
 
-// Store state change stream
 export interface StoreStream<T> {
 	subscribe: (handler: (value: T) => void) => () => void;
 	map: <R>(fn: (value: T) => R) => StoreStream<R>;
@@ -145,7 +144,6 @@ const createBaseStream = <T>(
 	};
 };
 
-// Build store property stream
 export const createStoreStream = <T, K extends keyof T>(
 	store: Store<T>,
 	key: K
@@ -172,7 +170,6 @@ export const createStoreStream = <T, K extends keyof T>(
 	});
 };
 
-// Observe entire store stream
 export const streamAll = <T>(
 	store: Store<T>
 ): StoreStream<ReturnType<Store<T>['getSnapshot']>> => {

package/src/registry/index.ts

@@ -21,22 +21,20 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+
 import type { Store } from '../core/types.js';
 import { getStoreConfig } from '../config/index.js';
 import { StoreNotFoundError } from '../errors.js';
 
 const stores = new Map<string, Store<unknown>>();
 
-// Register store instance
 export const registerStore = <T>(name: string, store: Store<T>): void => {
 	if (stores.has(name) && getStoreConfig().debug) {
-		// eslint-disable-next-line no-console
 		console.warn(`[store] Overwriting existing store: ${name}`);
 	}
 	stores.set(name, store as Store<unknown>);
 };
 
-// Access registered store
 export const getStore = <T>(name: string): Store<T> => {
 	const store = stores.get(name);
 	if (!store) {
@@ -45,16 +43,12 @@ export const getStore = <T>(name: string): Store<T> => {
 	return store as Store<T>;
 };
 
-// Detect registered store
 export const hasStore = (name: string): boolean => stores.has(name);
 
-// Remove registered store
 export const removeStore = (name: string): boolean => stores.delete(name);
 
-// Reset store registry
 export const clearStores = (): void => {
 	stores.clear();
 };
 
-// Access store names
 export const getStoreNames = (): string[] => Array.from(stores.keys());

package/src/validation/schema.ts

@@ -26,17 +26,14 @@ import { Effect, Schema, Duration, Predicate } from 'effect';
 import { TimeoutError } from '../errors.js';
 import { DEFAULT_TIMEOUT_MS } from '../config/constants.js';
 
-// State validation schema type
 export type StateSchema<T> = Schema.Schema<T, T>;
 
-// Validation check result
 export interface ValidationResult<T> {
 	success: boolean;
 	data: T | null;
 	errors: string[];
 }
 
-// Validate state synchronously
 export const validateState = <T>(
 	schema: StateSchema<T>,
 	state: unknown
@@ -60,7 +57,6 @@ export const validateState = <T>(
 	return result;
 };
 
-// Validate state asynchronously
 export const validateStateAsync = <T>(
 	schema: StateSchema<T>,
 	state: unknown,
@@ -92,7 +88,6 @@ export const validateStateAsync = <T>(
 	);
 };
 
-// Build validated state setter
 export const createValidatedSetter = <T extends Record<string, unknown>>(
 	schema: StateSchema<T>,
 	onValid: (state: T) => void,
@@ -111,7 +106,6 @@ export const createValidatedSetter = <T extends Record<string, unknown>>(
 	};
 };
 
-// Build field validator
 export const createFieldValidator = <T>(
 	schema: Schema.Schema<T, T>
 ): ((value: unknown) => T) => {
@@ -120,7 +114,6 @@ export const createFieldValidator = <T>(
 	};
 };
 
-// Build safe field setter
 export const createSafeFieldSetter = <T>(
 	schema: Schema.Schema<T, T>,
 	setter: (value: T) => void