@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,193 @@
+// Store Module - Middleware Operations
+// Clean Architecture: Middleware pipeline for cross-cutting concerns
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// MIDDLEWARE TYPES
+// ============================================
+
+export interface MiddlewareContext<T> {
+	store: Store<T>;
+	getState: () => T;
+	setState: (state: T | ((prev: T) => T)) => void;
+	action?: {
+		type: string;
+		payload?: unknown;
+	};
+}
+
+export type Middleware<T> = (
+	context: MiddlewareContext<T>,
+	next: () => void,
+) => void | Promise<void>;
+
+export interface MiddlewarePipeline<T> {
+	middlewares: Middleware<T>[];
+	use: (middleware: Middleware<T>) => MiddlewarePipeline<T>;
+	run: (
+		context: MiddlewareContext<T>,
+		action: () => void,
+	) => void | Promise<void>;
+}
+
+// ============================================
+// CREATE MIDDLEWARE PIPELINE
+// ============================================
+
+export const createMiddlewarePipeline = <T>(
+	...middlewares: Middleware<T>[]
+): MiddlewarePipeline<T> => {
+	return {
+		middlewares,
+		use(middleware: Middleware<T>): MiddlewarePipeline<T> {
+			return createMiddlewarePipeline<T>(...this.middlewares, middleware);
+		},
+		async run(
+			context: MiddlewareContext<T>,
+			action: () => void,
+		): Promise<void> {
+			const dispatch = async (i: number): Promise<void> => {
+				if (i >= this.middlewares.length) {
+					action();
+					return;
+				}
+
+				const middleware = this.middlewares[i];
+				await middleware(context, () => dispatch(i + 1));
+			};
+
+			await dispatch(0);
+		},
+	};
+};
+
+// ============================================
+// COMMON MIDDLEWARES
+// ============================================
+
+// Logger middleware
+export const loggerMiddleware = <T>(options?: {
+	logActions?: boolean;
+}): Middleware<T> => {
+	return (context, next, now: number = Date.now()) => {
+		const prevState = context.getState();
+		const timestamp = new Date(now).toISOString();
+
+		if (options?.logActions && context.action) {
+			console.log(
+				`[${timestamp}] Action:`,
+				context.action.type,
+				context.action.payload,
+			);
+		}
+
+		next();
+
+		const nextState = context.getState();
+		console.log(`[${timestamp}] State changed:`, prevState, "→", nextState);
+	};
+};
+
+// Analytics middleware
+export const analyticsMiddleware = <T>(options?: {
+	trackActions?: boolean;
+	trackStateChanges?: boolean;
+}): Middleware<T> => {
+	return (context, next) => {
+		if (options?.trackActions && context.action) {
+			// Send to analytics service
+			console.log("Analytics: Action tracked", context.action.type);
+		}
+
+		next();
+
+		if (options?.trackStateChanges) {
+			console.log("Analytics: State changed");
+		}
+	};
+};
+
+// Error handling middleware
+export const errorHandlingMiddleware = <T>(options?: {
+	onError?: (error: Error, context: MiddlewareContext<T>) => void;
+}): Middleware<T> => {
+	return async (context, next) => {
+		try {
+			await next();
+		} catch (error) {
+			console.error("Middleware error:", error);
+			options?.onError?.(error as Error, context);
+		}
+	};
+};
+
+// Performance monitoring middleware
+export const performanceMiddleware = <T>(options?: {
+	threshold?: number; // ms
+}): Middleware<T> => {
+	return async (_context, next) => {
+		const start = performance.now();
+		await next();
+		const duration = performance.now() - start;
+
+		if (options?.threshold && duration > options.threshold) {
+			console.warn(`Slow operation: ${duration.toFixed(2)}ms`);
+		}
+	};
+};
+
+// Validation middleware
+export const validationMiddleware = <T>(options?: {
+	validate?: (state: T) => boolean;
+	onError?: (state: T) => void;
+}): Middleware<T> => {
+	return (context, next) => {
+		const state = context.getState();
+		if (options?.validate && !options.validate(state)) {
+			options?.onError?.(state);
+			return;
+		}
+		next();
+	};
+};
+
+// Async middleware support
+export const asyncMiddleware = <T>(
+	middleware: Middleware<T>,
+): Middleware<T> => {
+	return async (context, next) => {
+		await middleware(context, next);
+	};
+};
+
+// ============================================
+// MIDDLEWARE COMPOSERS
+// ============================================
+
+export const composeMiddlewares = <T>(
+	...middlewares: Middleware<T>[]
+): Middleware<T> => {
+	return (context, next) => {
+		const dispatch = (i: number): void => {
+			if (i >= middlewares.length) {
+				next();
+				return;
+			}
+
+			middlewares[i](context, () => dispatch(i + 1));
+		};
+
+		dispatch(0);
+	};
+};
+
+// ============================================
+// MIDDLEWARE FACTORY
+// ============================================
+
+export const createMiddleware = <T>(
+	fn: (context: MiddlewareContext<T>, next: () => void) => void | Promise<void>,
+): Middleware<T> => {
+	return fn;
+};

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

@@ -0,0 +1,14 @@
+// Store Module - Domain Operations
+// Clean Architecture: Draft mutation helpers
+
+export const produce = <T>(recipe: (draft: T) => void): ((state: T) => T) => {
+	return (state: T): T => {
+		const draft = structuredClone(state);
+		recipe(draft);
+		return draft;
+	};
+};
+
+export const reconcile = <T>(data: Partial<T>): ((state: T) => T) => {
+	return (state: T): T => ({ ...state, ...data });
+};

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

@@ -0,0 +1,195 @@
+// Store Module - Normalization Operations
+// Clean Architecture: State normalization for memory optimization
+
+// ============================================
+// NORMALIZATION TYPES
+// ============================================
+
+export interface EntitySchema {
+	id: string;
+	[name: string]: any;
+}
+
+export interface NormalizedState<T> {
+	entities: Record<string, T>;
+	ids: string[];
+}
+
+export interface NormalizationOptions<T> {
+	idField?: keyof T;
+}
+
+// ============================================
+// NORMALIZE
+// ============================================
+
+export const normalize = <T extends Record<string, any>>(
+	data: Array<T>,
+	options?: NormalizationOptions<T>,
+): NormalizedState<T> => {
+	const idField = options?.idField || ("id" as keyof T);
+	const entities: Record<string, T> = {};
+	const ids: string[] = [];
+
+	for (const item of data) {
+		const id = String(item[idField] as string);
+		entities[id] = item as T;
+		ids.push(id);
+	}
+
+	return { entities, ids };
+};
+
+// ============================================
+// DENORMALIZE
+// ============================================
+
+export const denormalize = <T extends Record<string, any>>(
+	normalized: NormalizedState<T>,
+): Array<T> => {
+	return normalized.ids.map((id) => normalized.entities[id]);
+};
+
+// ============================================
+// MERGE NORMALIZED
+// ============================================
+
+export const mergeNormalized = <T extends Record<string, any>>(
+	existing: NormalizedState<T>,
+	newData: Array<T>,
+	options?: NormalizationOptions<T>,
+): NormalizedState<T> => {
+	const normalized = normalize(newData, options);
+	const entities = { ...existing.entities };
+	const ids = [...existing.ids];
+
+	for (const id of normalized.ids) {
+		if (!entities[id]) {
+			ids.push(id);
+		}
+		entities[id] = normalized.entities[id];
+	}
+
+	return { entities, ids };
+};
+
+// ============================================
+// UPDATE NORMALIZED ENTITY
+// ============================================
+
+export const updateNormalizedEntity = <T>(
+	normalized: NormalizedState<T>,
+	id: string,
+	updates: Partial<T>,
+): NormalizedState<T> => {
+	if (!normalized.entities[id]) {
+		return normalized;
+	}
+
+	return {
+		...normalized,
+		entities: {
+			...normalized.entities,
+			[id]: { ...normalized.entities[id], ...updates },
+		},
+	};
+};
+
+// ============================================
+// DELETE NORMALIZED ENTITY
+// ============================================
+
+export const deleteNormalizedEntity = <T>(
+	normalized: NormalizedState<T>,
+	id: string,
+): NormalizedState<T> => {
+	if (!normalized.entities[id]) {
+		return normalized;
+	}
+
+	const entities = { ...normalized.entities };
+	const ids = normalized.ids.filter((item) => item !== id);
+
+	delete entities[id];
+
+	return { entities, ids };
+};
+
+// ============================================
+// SELECT NORMALIZED ENTITY
+// ============================================
+
+export const selectNormalizedEntity = <T>(
+	normalized: NormalizedState<T>,
+	id: string,
+): T | undefined => {
+	return normalized.entities[id];
+};
+
+// ============================================
+// SELECT ALL NORMALIZED ENTITIES
+// ============================================
+
+export const selectAllNormalizedEntities = <T extends Record<string, any>>(
+	normalized: NormalizedState<T>,
+): Array<T> => {
+	return denormalize(normalized);
+};
+
+// ============================================
+// NORMALIZED STORE ADAPTER
+// ============================================
+
+export const createNormalizedStore = <T extends Record<string, any>>(
+	initialData: Array<T> = [],
+	options?: NormalizationOptions<T>,
+) => {
+	let normalized = normalize(initialData, options);
+	const listeners = new Set<(state: NormalizedState<T>) => void>();
+
+	const getState = (): NormalizedState<T> => normalized;
+
+	const setState = (
+		newData: Array<T> | ((prev: NormalizedState<T>) => NormalizedState<T>),
+	): void => {
+		if (typeof newData === "function") {
+			normalized = newData(normalized);
+		} else {
+			normalized = normalize(newData, options);
+		}
+
+		for (const listener of listeners) {
+			listener(normalized);
+		}
+	};
+
+	const subscribe = (
+		listener: (state: NormalizedState<T>) => void,
+	): (() => void) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+
+	return {
+		getState,
+		setState,
+		subscribe,
+		add: (item: T): void => {
+			setState([...denormalize(normalized), item]);
+		},
+		update: (id: string, updates: Partial<T>): void => {
+			normalized = updateNormalizedEntity(normalized, id, updates);
+			for (const listener of listeners) {
+				listener(normalized);
+			}
+		},
+		remove: (id: string): void => {
+			normalized = deleteNormalizedEntity(normalized, id);
+			for (const listener of listeners) {
+				listener(normalized);
+			}
+		},
+		select: (id: string) => selectNormalizedEntity(normalized, id),
+		selectAll: () => selectAllNormalizedEntities(normalized),
+	};
+};

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

@@ -0,0 +1,171 @@
+// Store Module - Optimistic Updates
+// Clean Architecture: Optimistic updates with automatic rollback
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// OPTIMISTIC UPDATE TYPES
+// ============================================
+
+export interface OptimisticUpdate<T> {
+	id: string;
+	optimisticState: T;
+	commit: () => Promise<void>;
+	rollback: () => void;
+}
+
+export interface OptimisticStore<T> extends Store<T> {
+	optimisticUpdates: Map<string, OptimisticUpdate<T>>;
+	optimisticUpdate: (update: OptimisticUpdate<T>) => void;
+	commitUpdate: (id: string) => Promise<void>;
+	rollbackUpdate: (id: string) => void;
+	clearOptimisticUpdates: () => void;
+}
+
+// ============================================
+// CREATE OPTIMISTIC STORE
+// ============================================
+
+export const createOptimisticStore = <T>(
+	baseStore: Store<T>,
+): OptimisticStore<T> => {
+	const optimisticUpdates = new Map<string, OptimisticUpdate<T>>();
+
+	const optimisticUpdate = (update: OptimisticUpdate<T>): void => {
+		optimisticUpdates.set(update.id, update);
+		baseStore.setState(update.optimisticState);
+	};
+
+	const commitUpdate = async (id: string): Promise<void> => {
+		const update = optimisticUpdates.get(id);
+		if (!update) return;
+
+		try {
+			await update.commit();
+			optimisticUpdates.delete(id);
+		} catch (error) {
+			rollbackUpdate(id);
+			throw error;
+		}
+	};
+
+	const rollbackUpdate = (id: string): void => {
+		const update = optimisticUpdates.get(id);
+		if (!update) return;
+
+		update.rollback();
+		optimisticUpdates.delete(id);
+	};
+
+	const clearOptimisticUpdates = (): void => {
+		optimisticUpdates.forEach((update) => {
+			update.rollback();
+		});
+		optimisticUpdates.clear();
+	};
+
+	return {
+		...baseStore,
+		optimisticUpdates,
+		optimisticUpdate,
+		commitUpdate,
+		rollbackUpdate,
+		clearOptimisticUpdates,
+	};
+};
+
+// ============================================
+// OPTIMISTIC UPDATE HELPER
+// ============================================
+
+export const withOptimisticUpdate = async <T>(
+	store: OptimisticStore<T>,
+	action: () => Promise<T>,
+	id: string,
+): Promise<void> => {
+	const previousState = store.getState();
+
+	// Create optimistic update
+	const update: OptimisticUpdate<T> = {
+		id,
+		optimisticState: previousState,
+		commit: async () => {
+			// Action is already executed, just confirm
+		},
+		rollback: () => {
+			store.setState(previousState);
+		},
+	};
+
+	store.optimisticUpdate(update);
+
+	try {
+		const result = await action();
+		store.setState(result);
+		await store.commitUpdate(id);
+		return;
+	} catch (error) {
+		store.rollbackUpdate(id);
+		throw error;
+	}
+};
+
+// ============================================
+// BATCH OPTIMISTIC UPDATES
+// ============================================
+
+export const batchOptimisticUpdates = async <T>(
+	store: OptimisticStore<T>,
+	updates: Array<() => Promise<T>>,
+	id: string,
+): Promise<void> => {
+	const previousState = store.getState();
+
+	const update: OptimisticUpdate<T> = {
+		id,
+		optimisticState: previousState,
+		commit: async () => {
+			// All updates already executed
+		},
+		rollback: () => {
+			store.setState(previousState);
+		},
+	};
+
+	store.optimisticUpdate(update);
+
+	try {
+		for (const updateFn of updates) {
+			const result = await updateFn();
+			store.setState(result);
+		}
+		await store.commitUpdate(id);
+		return;
+	} catch (error) {
+		store.rollbackUpdate(id);
+		throw error;
+	}
+};
+
+// ============================================
+// CONFLICT RESOLUTION
+// ============================================
+
+export type ConflictResolution<_T> = "optimistic" | "pessimistic" | "merge";
+
+export const resolveConflict = <T>(
+	optimistic: T,
+	server: T,
+	strategy: ConflictResolution<any>,
+): T => {
+	switch (strategy) {
+		case "optimistic":
+			return optimistic;
+		case "pessimistic":
+			return server;
+		case "merge":
+			return { ...server, ...optimistic } as T;
+		default:
+			return server;
+	}
+};

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

@@ -0,0 +1,26 @@
+// Store Module - Domain Operations
+// Clean Architecture: Persistence operations
+
+import type { PersistenceModel } from "#stores/modules/store/domain/models";
+
+export const createPersistenceModel = <T>(
+	key: string,
+	state: T,
+	timestamp: number,
+	version: string = "1.0.0",
+): PersistenceModel<T> => ({
+	key,
+	state,
+	version,
+	timestamp,
+});
+
+export const updatePersistenceState = <T>(
+	model: PersistenceModel<T>,
+	state: T,
+	timestamp: number,
+): PersistenceModel<T> => ({
+	...model,
+	state,
+	timestamp,
+});