@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,296 @@
+// Store Module - Reactive Query Operations
+// Clean Architecture: Async data fetching with store integration
+
+import { createStore } from "#stores/modules/store/application/usecases";
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// QUERY TYPES
+// ============================================
+
+export interface QueryState<T> {
+	data: T | null;
+	error: Error | null;
+	isLoading: boolean;
+	isFetching: boolean;
+	isSuccess: boolean;
+	isError: boolean;
+}
+
+export interface QueryOptions<T> {
+	queryKey: string;
+	queryFn: () => Promise<T>;
+	staleTime?: number;
+	cacheTime?: number;
+	refetchOnWindowFocus?: boolean;
+	refetchOnReconnect?: boolean;
+}
+
+export interface Query<T> extends Store<QueryState<T>> {
+	queryKey: string;
+	refetch: (now: number) => Promise<void>;
+	invalidate: (now: number) => void;
+}
+
+// ============================================
+// QUERY CACHE
+// ============================================
+
+interface CacheEntry<T> {
+	data: T;
+	timestamp: number;
+	staleTime: number;
+}
+
+const queryCache = new Map<string, CacheEntry<any>>();
+
+// ============================================
+// CREATE QUERY
+// ============================================
+
+export const createQuery = <T>(
+	options: QueryOptions<T>,
+	now: number,
+): Query<T> => {
+	const {
+		queryKey,
+		queryFn,
+		staleTime = 5 * 60 * 1000, // 5 minutes
+		// cacheTime = 10 * 60 * 1000, // 10 minutes (reserved for future use)
+	} = options;
+
+	const initialState: QueryState<T> = {
+		data: null,
+		error: null,
+		isLoading: true,
+		isFetching: false,
+		isSuccess: false,
+		isError: false,
+	};
+
+	const store = createStore<QueryState<T>>(initialState, {}, now);
+
+	const fetchData = async (fetchNow: number): Promise<void> => {
+		store.setState({
+			...store.getState(),
+			isFetching: true,
+		});
+
+		try {
+			// Check cache first
+			const cached = queryCache.get(queryKey);
+
+			if (cached && fetchNow - cached.timestamp < staleTime) {
+				store.setState({
+					data: cached.data,
+					error: null,
+					isLoading: false,
+					isFetching: false,
+					isSuccess: true,
+					isError: false,
+				});
+				return;
+			}
+
+			const data = await queryFn();
+
+			// Update cache
+			queryCache.set(queryKey, {
+				data,
+				timestamp: fetchNow,
+				staleTime,
+			});
+
+			store.setState({
+				data,
+				error: null,
+				isLoading: false,
+				isFetching: false,
+				isSuccess: true,
+				isError: false,
+			});
+		} catch (error) {
+			store.setState({
+				data: null,
+				error: error as Error,
+				isLoading: false,
+				isFetching: false,
+				isSuccess: false,
+				isError: true,
+			});
+		}
+	};
+
+	const refetch = async (refetchNow: number): Promise<void> => {
+		await fetchData(refetchNow);
+	};
+
+	const invalidate = (invalidateNow: number): void => {
+		queryCache.delete(queryKey);
+		store.setState(initialState);
+		fetchData(invalidateNow);
+	};
+
+	// Initial fetch
+	fetchData(now);
+
+	return {
+		...store,
+		queryKey,
+		refetch,
+		invalidate,
+	};
+};
+
+// ============================================
+// QUERY MUTATION
+// ============================================
+
+export interface MutationOptions<TData, TVariables> {
+	mutationFn: (variables: TVariables) => Promise<TData>;
+	onMutate?: (variables: TVariables) => Promise<unknown> | unknown;
+	onSuccess?: (data: TData, variables: TVariables) => void;
+	onError?: (error: Error, variables: TVariables) => void;
+	onSettled?: (
+		data: TData | undefined,
+		error: Error | null,
+		variables: TVariables,
+	) => void;
+}
+
+export interface MutationState<TData> {
+	data: TData | null;
+	error: Error | null;
+	isLoading: boolean;
+	isSuccess: boolean;
+	isError: boolean;
+}
+
+export const createMutation = <TData, TVariables>(
+	options: MutationOptions<TData, TVariables>,
+	now: number,
+): Store<MutationState<TData>> & {
+	mutate: (variables: TVariables) => Promise<TData>;
+	reset: () => void;
+} => {
+	const initialState: MutationState<TData> = {
+		data: null,
+		error: null,
+		isLoading: false,
+		isSuccess: false,
+		isError: false,
+	};
+
+	const store = createStore<MutationState<TData>>(initialState, {}, now);
+
+	const mutate = async (variables: TVariables): Promise<TData> => {
+		store.setState({
+			...store.getState(),
+			isLoading: true,
+		});
+
+		try {
+			await options.onMutate?.(variables);
+			const data = await options.mutationFn(variables);
+
+			store.setState({
+				data,
+				error: null,
+				isLoading: false,
+				isSuccess: true,
+				isError: false,
+			});
+
+			options.onSuccess?.(data, variables);
+			options.onSettled?.(data, null, variables);
+
+			return data;
+		} catch (error) {
+			const err = error as Error;
+
+			store.setState({
+				data: null,
+				error: err,
+				isLoading: false,
+				isSuccess: false,
+				isError: true,
+			});
+
+			options.onError?.(err, variables);
+			options.onSettled?.(undefined, err, variables);
+
+			throw err;
+		}
+	};
+
+	const reset = (): void => {
+		store.setState(initialState);
+	};
+
+	return {
+		...store,
+		mutate,
+		reset,
+	};
+};
+
+// ============================================
+// QUERY CLIENT
+// ============================================
+
+export interface QueryClient {
+	queries: Map<string, Query<any>>;
+	getQuery: <T>(queryKey: string) => Query<T> | undefined;
+	setQuery: <T>(
+		queryKey: string,
+		options: QueryOptions<T>,
+		now: number,
+	) => Query<T>;
+	clearQueries: (now: number) => void;
+	invalidateQueries: (
+		now: number,
+		predicate?: (queryKey: string) => boolean,
+	) => void;
+}
+
+export const createQueryClient = (): QueryClient => {
+	const queries = new Map<string, Query<any>>();
+
+	return {
+		queries,
+		getQuery: <T>(queryKey: string): Query<T> | undefined => {
+			return queries.get(queryKey) as Query<T> | undefined;
+		},
+		setQuery: <T>(
+			queryKey: string,
+			options: QueryOptions<T>,
+			now: number,
+		): Query<T> => {
+			const query = createQuery<T>({ ...options, queryKey }, now);
+			queries.set(queryKey, query as Query<any>);
+			return query;
+		},
+		clearQueries: (now: number): void => {
+			for (const query of queries.values()) {
+				query.invalidate(now);
+			}
+			queries.clear();
+		},
+		invalidateQueries: (
+			now: number,
+			predicate?: (queryKey: string) => boolean,
+		): void => {
+			if (predicate) {
+				for (const [key, query] of queries) {
+					if (predicate(key)) {
+						query.invalidate(now);
+					}
+				}
+			} else {
+				for (const query of queries.values()) {
+					query.invalidate(now);
+				}
+			}
+		},
+	};
+};

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

@@ -0,0 +1,112 @@
+// Store Module - Selector Operations
+// Clean Architecture: Memoized selector operations
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// SELECTOR CACHE
+// ============================================
+
+interface SelectorCache<T, U> {
+	selector: (state: T) => U;
+	lastState: T;
+	lastResult: U;
+	dependencies: unknown[];
+}
+
+// Use Map instead of WeakMap for better cache control
+let selectorCaches = new Map<object, SelectorCache<any, any>[]>();
+
+// ============================================
+// CREATE SELECTOR
+// ============================================
+
+export const createSelector = <T, U>(
+	selector: (state: T) => U,
+): ((state: T) => U) => {
+	return (state: T): U => {
+		const cacheKey = state as object;
+		let caches = selectorCaches.get(cacheKey);
+
+		if (!caches) {
+			caches = [];
+			selectorCaches.set(cacheKey, caches);
+		}
+
+		const existingCache = caches.find(
+			(c) => c.selector === selector && c.lastState === state,
+		);
+
+		if (existingCache) {
+			return existingCache.lastResult;
+		}
+
+		const result = selector(state);
+		const newCache: SelectorCache<T, U> = {
+			selector,
+			lastState: state,
+			lastResult: result,
+			dependencies: [],
+		};
+
+		caches.push(newCache);
+		return result;
+	};
+};
+
+// ============================================
+// CREATE COMPOSED SELECTOR
+// ============================================
+
+export const createSelectorFromStores = <T extends readonly Store<any>[], U>(
+	stores: T,
+	combiner: (
+		...states: { [K in keyof T]: T[K] extends Store<infer S> ? S : never }
+	) => U,
+): (() => U) => {
+	let lastStates: unknown[] = [];
+	let lastResult: U;
+
+	return (): U => {
+		const currentStates = stores.map((store) => store.getState());
+
+		if (
+			lastStates.length === currentStates.length &&
+			lastStates.every((state, i) => state === currentStates[i])
+		) {
+			return lastResult;
+		}
+
+		lastStates = currentStates;
+		lastResult = combiner(...(currentStates as any));
+		return lastResult;
+	};
+};
+
+// ============================================
+// CREATE DEPENDENT SELECTOR
+// ============================================
+
+export const createDependentSelector = <T, U, V>(
+	inputSelector: (state: T) => U,
+	outputSelector: (input: U) => V,
+): ((state: T) => V) => {
+	return createSelector((state: T) => {
+		const input = inputSelector(state);
+		return outputSelector(input);
+	});
+};
+
+// ============================================
+// CLEAR SELECTOR CACHE
+// ============================================
+
+export const clearSelectorCache = (state: object): void => {
+	selectorCaches.delete(state);
+};
+
+export const clearAllSelectorCaches = (): void => {
+	// WeakMap doesn't have forEach, create a new WeakMap to clear all
+	const newCaches = new WeakMap<object, SelectorCache<any, any>[]>();
+	selectorCaches = newCaches as any;
+};

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

@@ -0,0 +1,52 @@
+// Store Module - Domain Operations
+// Clean Architecture: Store operations
+
+import type { StoreModel } from "#stores/modules/store/domain/models";
+import type { StoreConfig, StoreListener } from "#stores/modules/store/types";
+
+export const createStoreModel = <T>(
+	initialState: T,
+	now: number,
+	config: StoreConfig = {},
+): StoreModel<T> => ({
+	state: initialState,
+	listeners: [],
+	config,
+	createdAt: now,
+	updatedAt: now,
+});
+
+export const updateStoreState = <T>(
+	model: StoreModel<T>,
+	newState: T | ((prev: T) => T),
+	now: number,
+): StoreModel<T> => ({
+	...model,
+	state:
+		typeof newState === "function"
+			? (newState as (prev: T) => T)(model.state)
+			: newState,
+	updatedAt: now,
+});
+
+export const addStoreListener = <T>(
+	model: StoreModel<T>,
+	listener: StoreListener<T>,
+): StoreModel<T> => ({
+	...model,
+	listeners: [...model.listeners, listener],
+});
+
+export const removeStoreListener = <T>(
+	model: StoreModel<T>,
+	listener: StoreListener<T>,
+): StoreModel<T> => ({
+	...model,
+	listeners: model.listeners.filter((l) => l !== listener),
+});
+
+export const notifyListeners = <T>(model: StoreModel<T>): void => {
+	for (const listener of model.listeners) {
+		listener(model.state);
+	}
+};

package/src/stores/modules/store/domain/operations/time-machine.ts

@@ -0,0 +1,240 @@
+// Store Module - Time Machine Operations
+// Clean Architecture: State time travel and history management
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// TIME MACHINE TYPES
+// ============================================
+
+export interface TimeMachineState<T> {
+	past: T[];
+	present: T;
+	future: T[];
+	maxHistory?: number;
+}
+
+export interface TimeMachineOptions {
+	maxHistory?: number;
+	enableBranching?: boolean;
+}
+
+export interface TimeMachineStore<T> extends Store<T> {
+	timeMachine: TimeMachine<T>;
+	undo: () => T | null;
+	redo: () => T | null;
+	canUndo: () => boolean;
+	canRedo: () => boolean;
+	jumpTo: (index: number) => T | null;
+	reset: (newInitialState: T) => void;
+	getHistory: () => TimeMachineState<T>;
+}
+
+// ============================================
+// TIME MACHINE
+// ============================================
+
+export class TimeMachine<T> {
+	private state: TimeMachineState<T>;
+	private options: TimeMachineOptions;
+
+	constructor(initialState: T, options: TimeMachineOptions = {}) {
+		this.options = {
+			maxHistory: 50,
+			enableBranching: false,
+			...options,
+		};
+
+		this.state = {
+			past: [],
+			present: initialState,
+			future: [],
+			maxHistory: this.options.maxHistory,
+		};
+	}
+
+	push(newState: T): void {
+		this.state.past.push(this.state.present);
+		this.state.present = newState;
+		this.state.future = [];
+
+		// Trim history if exceeding max
+		if (this.state.past.length > (this.options.maxHistory || 50)) {
+			this.state.past.shift();
+		}
+	}
+
+	undo(): T | null {
+		if (this.state.past.length === 0) {
+			return null;
+		}
+
+		const previous = this.state.past.pop();
+		if (previous === undefined) {
+			return null;
+		}
+
+		this.state.future.unshift(this.state.present);
+		this.state.present = previous;
+
+		return this.state.present;
+	}
+
+	redo(): T | null {
+		if (this.state.future.length === 0) {
+			return null;
+		}
+
+		const next = this.state.future.shift();
+		if (next === undefined) {
+			return null;
+		}
+
+		this.state.past.push(this.state.present);
+		this.state.present = next;
+
+		return this.state.present;
+	}
+
+	canUndo(): boolean {
+		return this.state.past.length > 0;
+	}
+
+	canRedo(): boolean {
+		return this.state.future.length > 0;
+	}
+
+	getState(): TimeMachineState<T> {
+		return {
+			past: [...this.state.past],
+			present: this.state.present,
+			future: [...this.state.future],
+			maxHistory: this.state.maxHistory,
+		};
+	}
+
+	reset(initialState: T): void {
+		this.state = {
+			past: [],
+			present: initialState,
+			future: [],
+			maxHistory: this.options.maxHistory,
+		};
+	}
+
+	jumpTo(pastIndex: number): T | null {
+		if (pastIndex < 0 || pastIndex >= this.state.past.length) {
+			return null;
+		}
+
+		const targetState = this.state.past[pastIndex];
+		this.state.future = [
+			...this.state.past.slice(pastIndex + 1),
+			this.state.present,
+			...this.state.future,
+		];
+		this.state.past = this.state.past.slice(0, pastIndex);
+		this.state.present = targetState;
+
+		return this.state.present;
+	}
+}
+
+// ============================================
+// TIME MACHINE STORE
+// ============================================
+
+export const createTimeMachineStore = <T>(
+	initialState: T,
+	options: TimeMachineOptions = {},
+): TimeMachineStore<T> => {
+	const timeMachine = new TimeMachine(initialState, options);
+	const listeners = new Set<(state: T) => void>();
+
+	const store: Store<T> = {
+		getState: (): T => {
+			return timeMachine.getState().present;
+		},
+		setState: (state: T | ((prev: T) => T)): void => {
+			const currentState = store.getState();
+			const newState =
+				typeof state === "function"
+					? (state as (prev: T) => T)(currentState)
+					: state;
+
+			timeMachine.push(newState);
+
+			for (const listener of listeners) {
+				listener(newState);
+			}
+		},
+		subscribe: (listener: (state: T) => void): (() => void) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+	};
+
+	return {
+		...store,
+		timeMachine,
+		undo: (): T | null => {
+			const result = timeMachine.undo();
+			if (result !== null) {
+				for (const listener of listeners) {
+					listener(result);
+				}
+			}
+			return result;
+		},
+		redo: (): T | null => {
+			const result = timeMachine.redo();
+			if (result !== null) {
+				for (const listener of listeners) {
+					listener(result);
+				}
+			}
+			return result;
+		},
+		canUndo: () => timeMachine.canUndo(),
+		canRedo: () => timeMachine.canRedo(),
+		jumpTo: (index: number): T | null => {
+			const result = timeMachine.jumpTo(index);
+			if (result !== null) {
+				for (const listener of listeners) {
+					listener(result);
+				}
+			}
+			return result;
+		},
+		reset: (newInitialState: T): void => {
+			timeMachine.reset(newInitialState);
+			for (const listener of listeners) {
+				listener(newInitialState);
+			}
+		},
+		getHistory: () => timeMachine.getState(),
+	} as TimeMachineStore<T>;
+};
+
+// ============================================
+// TIME TRAVEL MIDDLEWARE
+// ============================================
+
+export const timeTravelMiddleware = <T>(options?: TimeMachineOptions) => {
+	return (store: Store<T>) => {
+		const timeMachineStore = createTimeMachineStore(store.getState(), options);
+
+		// Sync original store with time machine
+		timeMachineStore.subscribe((state) => {
+			store.setState(state);
+		});
+
+		return {
+			undo: () => timeMachineStore.undo(),
+			redo: () => timeMachineStore.redo(),
+			canUndo: () => timeMachineStore.canUndo(),
+			canRedo: () => timeMachineStore.canRedo(),
+			getHistory: () => timeMachineStore.getHistory(),
+		};
+	};
+};