@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/stores/modules/store/domain/operations/event-bus.ts

@@ -0,0 +1,255 @@
+// Store Module - Event Bus Operations
+// Clean Architecture: Event-driven state management
+
+import type { IClock, ILogger } from "#stores/modules/store/ports";
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// EVENT BUS TYPES
+// ============================================
+
+export interface EventBusEvent<T = unknown> {
+	type: string;
+	payload: T;
+	timestamp: number;
+	source?: string;
+}
+
+export type EventHandler<T = unknown> = (
+	event: EventBusEvent<T>,
+) => void | Promise<void>;
+
+export interface EventBusOptions {
+	maxListeners?: number;
+	enableWildcards?: boolean;
+	logger?: ILogger;
+	clock?: IClock;
+}
+
+// ============================================
+// EVENT BUS
+// ============================================
+
+export class EventBus<T = unknown> {
+	private listeners = new Map<string, Set<EventHandler<T>>>();
+	private wildcardListeners = new Set<EventHandler<T>>();
+	private eventHistory: EventBusEvent<T>[] = [];
+	private maxHistory = 100;
+	private options: EventBusOptions;
+
+	constructor(options: EventBusOptions = {}) {
+		this.options = {
+			maxListeners: 100,
+			enableWildcards: true,
+			...options,
+		};
+	}
+
+	on(eventType: string, handler: EventHandler<T>): () => void {
+		let listeners = this.listeners.get(eventType);
+		if (!listeners) {
+			listeners = new Set();
+			this.listeners.set(eventType, listeners);
+		}
+
+		if (listeners.size >= (this.options.maxListeners || 100)) {
+			this.options.logger?.warn(
+				`Max listeners (${this.options.maxListeners}) reached for event: ${eventType}`,
+			);
+		}
+
+		listeners.add(handler);
+
+		return () => this.off(eventType, handler);
+	}
+
+	off(eventType: string, handler: EventHandler<T>): void {
+		const listeners = this.listeners.get(eventType);
+		if (listeners) {
+			listeners.delete(handler);
+			if (listeners.size === 0) {
+				this.listeners.delete(eventType);
+			}
+		}
+	}
+
+	onWildcard(handler: EventHandler<T>): () => void {
+		if (!this.options.enableWildcards) {
+			throw new Error("Wildcard listeners are not enabled");
+		}
+
+		this.wildcardListeners.add(handler);
+
+		return () => this.offWildcard(handler);
+	}
+
+	offWildcard(handler: EventHandler<T>): void {
+		this.wildcardListeners.delete(handler);
+	}
+
+	emit(eventType: string, payload: T, now: number, source?: string): void {
+		const event: EventBusEvent<T> = {
+			type: eventType,
+			payload,
+			timestamp: now,
+			source,
+		};
+
+		// Add to history
+		this.eventHistory.push(event);
+		if (this.eventHistory.length > this.maxHistory) {
+			this.eventHistory.shift();
+		}
+
+		// Notify specific listeners
+		const listeners = this.listeners.get(eventType);
+		if (listeners) {
+			listeners.forEach((handler) => {
+				try {
+					handler(event);
+				} catch (error) {
+					this.options.logger?.error(
+						`Error in event handler for ${eventType}:`,
+						error,
+					);
+				}
+			});
+		}
+
+		// Notify wildcard listeners
+		if (this.options.enableWildcards) {
+			this.wildcardListeners.forEach((handler) => {
+				try {
+					handler(event);
+				} catch (error) {
+					this.options.logger?.error(
+						`Error in wildcard event handler for ${eventType}:`,
+						error,
+					);
+				}
+			});
+		}
+	}
+
+	async emitAsync(
+		eventType: string,
+		payload: T,
+		now: number,
+		source?: string,
+	): Promise<void> {
+		const event: EventBusEvent<T> = {
+			type: eventType,
+			payload,
+			timestamp: now,
+			source,
+		};
+
+		// Add to history
+		this.eventHistory.push(event);
+		if (this.eventHistory.length > this.maxHistory) {
+			this.eventHistory.shift();
+		}
+
+		// Notify specific listeners
+		const listeners = this.listeners.get(eventType);
+		if (listeners) {
+			const promises = Array.from(listeners).map((handler) => {
+				try {
+					return Promise.resolve(handler(event));
+				} catch (error) {
+					this.options.logger?.error(
+						`Error in async event handler for ${eventType}:`,
+						error,
+					);
+					return Promise.resolve();
+				}
+			});
+			await Promise.all(promises);
+		}
+
+		// Notify wildcard listeners
+		if (this.options.enableWildcards) {
+			const wildcardPromises = Array.from(this.wildcardListeners).map(
+				(handler) => {
+					try {
+						return Promise.resolve(handler(event));
+					} catch (error) {
+						this.options.logger?.error(
+							`Error in async wildcard event handler for ${eventType}:`,
+							error,
+						);
+						return Promise.resolve();
+					}
+				},
+			);
+			await Promise.all(wildcardPromises);
+		}
+	}
+
+	getHistory(): EventBusEvent<T>[] {
+		return [...this.eventHistory];
+	}
+
+	clearHistory(): void {
+		this.eventHistory = [];
+	}
+
+	getListenerCount(eventType?: string): number {
+		if (eventType) {
+			return this.listeners.get(eventType)?.size || 0;
+		}
+		return Array.from(this.listeners.values()).reduce(
+			(sum, set) => sum + set.size,
+			0,
+		);
+	}
+
+	clear(): void {
+		this.listeners.clear();
+		this.wildcardListeners.clear();
+		this.eventHistory = [];
+	}
+}
+
+// ============================================
+// STORE EVENT BUS INTEGRATION
+// ============================================
+
+export const createStoreEventBus = <T>(
+	store: Store<T>,
+	options: EventBusOptions & { clock: IClock },
+): { eventBus: EventBus<T>; store: Store<T> } => {
+	const eventBus = new EventBus<T>(options);
+
+	// Create event-emitting store wrapper
+	const eventStore: Store<T> = {
+		getState: store.getState,
+		setState: (state: T | ((prev: T) => T)): void => {
+			const currentState = store.getState();
+			const newState =
+				typeof state === "function"
+					? (state as (prev: T) => T)(currentState)
+					: state;
+
+			// Emit state change event
+			eventBus.emit("state:change", newState, options.clock.now(), "store");
+
+			store.setState(state);
+		},
+		subscribe: store.subscribe,
+	};
+
+	return { eventBus, store: eventStore };
+};
+
+// ============================================
+// EVENT TYPES
+// ============================================
+
+export const StoreEventTypes = {
+	STATE_CHANGE: "state:change",
+	STATE_RESET: "state:reset",
+	SUBSCRIBE: "store:subscribe",
+	UNSUBSCRIBE: "store:unsubscribe",
+	ERROR: "store:error",
+} as const;

package/src/stores/modules/store/domain/operations/history-operations.ts

@@ -0,0 +1,101 @@
+// Store Module - Domain Operations
+// Clean Architecture: History operations
+
+import type {
+	StoreActionModel,
+	StoreHistoryModel,
+} from "#stores/modules/store/domain/models";
+import type { StoreAction } from "#stores/modules/store/types";
+
+export const createActionModel = <T>(
+	action: StoreAction,
+	previousState: T,
+	nextState: T,
+	timestamp: number,
+): StoreActionModel<T> => ({
+	action,
+	previousState,
+	nextState,
+	timestamp,
+});
+
+export const createHistoryModel = <T>(
+	initialState: T,
+	maxSize: number = 50,
+): StoreHistoryModel<T> => ({
+	history: {
+		past: [],
+		present: initialState,
+		future: [],
+	},
+	maxSize,
+	currentIndex: 0,
+});
+
+export const pushToHistory = <T>(
+	model: StoreHistoryModel<T>,
+	state: T,
+): StoreHistoryModel<T> => {
+	const newPast = [...model.history.past, model.history.present];
+	const newPresent = state;
+
+	if (newPast.length > model.maxSize) {
+		newPast.shift();
+	}
+
+	return {
+		...model,
+		history: {
+			past: newPast,
+			present: newPresent,
+			future: [],
+		},
+		currentIndex: Math.min(model.currentIndex + 1, model.maxSize),
+	};
+};
+
+export const undoHistory = <T>(
+	model: StoreHistoryModel<T>,
+): StoreHistoryModel<T> => {
+	if (model.history.past.length === 0) return model;
+
+	const previous = model.history.past[model.history.past.length - 1];
+	const newPast = model.history.past.slice(0, -1);
+	const newFuture = [model.history.present, ...model.history.future];
+
+	return {
+		...model,
+		history: {
+			past: newPast,
+			present: previous,
+			future: newFuture,
+		},
+		currentIndex: Math.max(model.currentIndex - 1, 0),
+	};
+};
+
+export const redoHistory = <T>(
+	model: StoreHistoryModel<T>,
+): StoreHistoryModel<T> => {
+	if (model.history.future.length === 0) return model;
+
+	const next = model.history.future[0];
+	const newPast = [...model.history.past, model.history.present];
+	const newFuture = model.history.future.slice(1);
+
+	return {
+		...model,
+		history: {
+			past: newPast,
+			present: next,
+			future: newFuture,
+		},
+		currentIndex: Math.min(model.currentIndex + 1, model.maxSize),
+	};
+};
+
+export const canUndo = <T>(model: StoreHistoryModel<T>): boolean =>
+	model.history.past.length > 0;
+
+export const canRedo = <T>(model: StoreHistoryModel<T>): boolean =>
+	model.history.future.length > 0;

package/src/stores/modules/store/domain/operations/hydration.ts

@@ -0,0 +1,159 @@
+// Store Module - Hydration Operations
+// Clean Architecture: Server-side rendering hydration support
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// HYDRATION TYPES
+// ============================================
+
+export interface HydrationOptions<T> {
+	validate?: (state: unknown) => state is T;
+	onError?: (error: Error) => void;
+	migrate?: boolean;
+}
+
+export interface HydrationResult<T> {
+	state: T;
+	version: string;
+	isHydrated: boolean;
+}
+
+// ============================================
+// SERIALIZE STATE
+// ============================================
+
+export const serializeState = <T>(state: T): string => {
+	try {
+		return JSON.stringify(state);
+	} catch (error) {
+		throw new Error(`Failed to serialize state: ${error}`);
+	}
+};
+
+// ============================================
+// DESERIALIZE STATE
+// ============================================
+
+export const deserializeState = <T>(
+	serialized: string,
+	options?: HydrationOptions<T>,
+): T => {
+	try {
+		const parsed = JSON.parse(serialized);
+
+		if (options?.validate && !options.validate(parsed)) {
+			throw new Error("Invalid state data");
+		}
+
+		return parsed;
+	} catch (error) {
+		if (options?.onError) {
+			options.onError(error as Error);
+		}
+		throw error;
+	}
+};
+
+// ============================================
+// HYDRATE STORE
+// ============================================
+
+export const hydrateStore = <T>(
+	store: Store<T>,
+	serializedState: string,
+	options?: HydrationOptions<T>,
+): HydrationResult<T> => {
+	try {
+		const state = deserializeState<T>(serializedState, options);
+		store.setState(state);
+
+		return {
+			state,
+			version: "1.0.0",
+			isHydrated: true,
+		};
+	} catch (error) {
+		if (options?.onError) {
+			options.onError(error as Error);
+		}
+
+		return {
+			state: store.getState(),
+			version: "1.0.0",
+			isHydrated: false,
+		};
+	}
+};
+
+// ============================================
+// HYDRATE FROM SERVER
+// ============================================
+
+export const hydrateFromServer = <T>(
+	store: Store<T>,
+	serverState: T,
+	options?: HydrationOptions<T>,
+): HydrationResult<T> => {
+	try {
+		if (options?.validate && !options.validate(serverState)) {
+			throw new Error("Invalid server state");
+		}
+
+		store.setState(serverState);
+
+		return {
+			state: serverState,
+			version: "1.0.0",
+			isHydrated: true,
+		};
+	} catch (error) {
+		if (options?.onError) {
+			options.onError(error as Error);
+		}
+
+		return {
+			state: store.getState(),
+			version: "1.0.0",
+			isHydrated: false,
+		};
+	}
+};
+
+// ============================================
+// DEHYDRATE STORE
+// ============================================
+
+export const dehydrateStore = <T>(store: Store<T>): string => {
+	return serializeState(store.getState());
+};
+
+// ============================================
+// HYDRATION MIDDLEWARE
+// ============================================
+
+export const createHydrationMiddleware = <T>(options?: HydrationOptions<T>) => {
+	return (store: Store<T>) => {
+		// Check for server-rendered state in window
+		if (typeof window !== "undefined") {
+			const serverState = (window as any).__SERVER_STATE__;
+			if (serverState) {
+				hydrateFromServer(store, serverState, options);
+				// Clean up to prevent memory leaks
+				delete (window as any).__SERVER_STATE__;
+			}
+		}
+	};
+};
+
+// ============================================
+// HYDRATION VALIDATOR
+// ============================================
+
+export const createHydrationValidator = <T>(schema: {
+	validate: (data: unknown) => data is T;
+}) => {
+	return (data: unknown): data is T => {
+		return schema.validate(data);
+	};
+};

package/src/stores/modules/store/domain/operations/immutable.ts

@@ -0,0 +1,173 @@
+// Store Module - Immutable State Enforcement
+// Clean Architecture: Ensure state immutability with deep freezing
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// IMMUTABILITY TYPES
+// ============================================
+
+export interface ImmutabilityOptions {
+	deep?: boolean;
+	onMutationAttempt?: (path: string, operation: string) => void;
+}
+
+// ============================================
+// DEEP FREEZE
+// ============================================
+
+export const deepFreeze = <T>(obj: T): T => {
+	if (obj === null || typeof obj !== "object") {
+		return obj;
+	}
+
+	Object.freeze(obj);
+
+	Object.getOwnPropertyNames(obj).forEach((prop) => {
+		const value = (obj as any)[prop];
+		if (
+			typeof value === "object" &&
+			value !== null &&
+			!Object.isFrozen(value)
+		) {
+			deepFreeze(value);
+		}
+	});
+
+	return obj;
+};
+
+// ============================================
+// DEEP CLONE
+// ============================================
+
+export const deepClone = <T>(obj: T): T => {
+	if (obj === null || typeof obj !== "object") {
+		return obj;
+	}
+
+	if (Array.isArray(obj)) {
+		return obj.map((item) => deepClone(item)) as T;
+	}
+
+	const cloned = {} as T;
+	for (const key in obj) {
+		if (Object.hasOwn(obj, key)) {
+			cloned[key] = deepClone(obj[key]);
+		}
+	}
+
+	return cloned;
+};
+
+// ============================================
+// IMMUTABLE STORE
+// ============================================
+
+export const createImmutableStore = <T>(
+	baseStore: Store<T>,
+	options: ImmutabilityOptions = {},
+): Store<T> => {
+	const { deep = true } = options;
+
+	const freezeState = (state: T): T =>
+		deep ? deepFreeze(state) : (Object.freeze(state) as T);
+
+	return {
+		getState: (): T => freezeState(baseStore.getState()),
+		setState: (state: T | ((prev: T) => T)): void => {
+			const currentState = baseStore.getState();
+			const newState =
+				typeof state === "function"
+					? (state as (prev: T) => T)(currentState)
+					: state;
+
+			baseStore.setState(freezeState(newState));
+		},
+		subscribe: baseStore.subscribe,
+	};
+};
+
+// ============================================
+// PROXY STORE (RUNTIME IMMUTABILITY)
+// ============================================
+
+export const createProxyStore = <T extends Record<string, unknown>>(
+	baseStore: Store<T>,
+	options: ImmutabilityOptions = {},
+): Store<T> => {
+	const { onMutationAttempt } = options;
+
+	const trackMutation = (path: string, operation: string): void => {
+		onMutationAttempt?.(path, operation);
+	};
+
+	const createProxy = (state: T): T => {
+		const handler: ProxyHandler<T> = {
+			get(target, prop) {
+				const key = prop as keyof T;
+				const value = target[key];
+				if (typeof value === "object" && value !== null) {
+					return createProxy(value as T);
+				}
+				return value;
+			},
+			set() {
+				trackMutation("", "set");
+				throw new Error("Cannot mutate immutable state");
+			},
+			deleteProperty() {
+				trackMutation("", "delete");
+				throw new Error("Cannot delete properties on immutable state");
+			},
+		};
+
+		return new Proxy(state, handler);
+	};
+
+	return {
+		getState: (): T => createProxy(baseStore.getState()),
+		setState: (state: T | ((prev: T) => T)): void => {
+			baseStore.setState(state);
+		},
+		subscribe: baseStore.subscribe,
+	};
+};
+
+// ============================================
+// IMMUTABILITY CHECKER
+// ============================================
+
+export const isImmutable = (obj: unknown): boolean => {
+	if (obj === null || typeof obj !== "object") {
+		return true;
+	}
+
+	if (!Object.isFrozen(obj)) {
+		return false;
+	}
+
+	for (const key in obj) {
+		if (Object.hasOwn(obj, key)) {
+			const value = (obj as any)[key];
+			if (typeof value === "object" && value !== null && !isImmutable(value)) {
+				return false;
+			}
+		}
+	}
+
+	return true;
+};
+
+// ============================================
+// PRODUCER (IMMUTABLE UPDATE)
+// ============================================
+
+export const produceImmutable = <T>(
+	state: T,
+	recipe: (draft: T) => void,
+): T => {
+	const draft = deepClone(state);
+	recipe(draft);
+	return draft;
+};

package/src/stores/modules/store/domain/operations/index.ts

@@ -0,0 +1,21 @@
+// Store Module - Domain Operations
+// Clean Architecture: Re-export all operations
+
+export * from "./actions";
+export * from "./composition";
+export * from "./derived-operations";
+export * from "./diffing";
+export * from "./event-bus";
+export * from "./history-operations";
+export * from "./hydration";
+export * from "./immutable";
+export * from "./middleware";
+export * from "./mutations";
+export * from "./normalization";
+export * from "./optimistic";
+export * from "./persistence-operations";
+export * from "./queries";
+export * from "./selectors";
+export * from "./store-operations";
+export * from "./time-machine";
+export * from "./transactions";