@sylphx/lens-server 2.1.0 → 2.3.0

package/src/server/create.ts

@@ -18,15 +18,18 @@
 import {
 	type ContextValue,
 	createEmit,
+	type EmitCommand,
 	type EntityDef,
 	flattenRouter,
 	type InferRouterContext,
 	isEntityDef,
 	isMutationDef,
 	isQueryDef,
+	type Observable,
 	type ResolverDef,
 	type RouterDef,
 	toResolverMap,
+	valuesEqual,
 } from "@sylphx/lens-core";
 import { createContext, runWithContext } from "../context/index.js";
 import {
@@ -39,7 +42,7 @@ import {
 	type UpdateFieldsContext,
 } from "../plugin/types.js";
 import { DataLoader } from "./dataloader.js";
-import { applySelection } from "./selection.js";
+import { applySelection, extractNestedInputs } from "./selection.js";
 import type {
 	ClientSendFn,
 	EntitiesMap,
@@ -192,135 +195,449 @@ class LensServerImpl<
 		};
 	}
 
-	async execute(op: LensOperation): Promise<LensResult> {
+	/**
+	 * Execute operation and return Observable.
+	 *
+	 * Always returns Observable<LensResult>:
+	 * - One-shot: emits once, then completes
+	 * - Streaming: emits multiple times (AsyncIterable or emit-based)
+	 */
+	execute(op: LensOperation): Observable<LensResult> {
 		const { path, input } = op;
 
-		try {
-			if (this.queries[path]) {
-				const data = await this.executeQuery(path, input);
-				return { data };
-			}
-			if (this.mutations[path]) {
-				const data = await this.executeMutation(path, input);
-				return { data };
-			}
-			return { error: new Error(`Operation not found: ${path}`) };
-		} catch (error) {
-			return { error: error instanceof Error ? error : new Error(String(error)) };
-		}
-	}
-
-	// =========================================================================
-	// Query/Mutation Execution
-	// =========================================================================
-
-	private async executeQuery<TInput, TOutput>(name: string, input?: TInput): Promise<TOutput> {
-		const queryDef = this.queries[name];
-		if (!queryDef) throw new Error(`Query not found: ${name}`);
-
-		// Extract $select from input
-		let select: SelectionObject | undefined;
-		let cleanInput = input;
-		if (input && typeof input === "object" && "$select" in input) {
-			const { $select, ...rest } = input as Record<string, unknown>;
-			select = $select as SelectionObject;
-			cleanInput = (Object.keys(rest).length > 0 ? rest : undefined) as TInput;
-		}
-
-		// Validate input
-		if (queryDef._input && cleanInput !== undefined) {
-			const result = queryDef._input.safeParse(cleanInput);
-			if (!result.success) {
-				throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
-			}
+		// Check if operation exists
+		const isQuery = !!this.queries[path];
+		const isMutation = !!this.mutations[path];
+
+		if (!isQuery && !isMutation) {
+			return {
+				subscribe: (observer) => {
+					observer.next?.({ error: new Error(`Operation not found: ${path}`) });
+					observer.complete?.();
+					return { unsubscribe: () => {} };
+				},
+			};
 		}
 
-		const context = await this.contextFactory();
-
-		try {
-			return await runWithContext(this.ctx, context, async () => {
-				const resolver = queryDef._resolve;
-				if (!resolver) throw new Error(`Query ${name} has no resolver`);
+		return this.executeAsObservable(path, input, isQuery);
+	}
 
-				const emit = createEmit(() => {});
-				const onCleanup = () => () => {};
-				const lensContext = { ...context, emit, onCleanup };
+	/**
+	 * Execute operation and return Observable.
+	 * Observable allows streaming for AsyncIterable resolvers and emit-based updates.
+	 */
+	private executeAsObservable(
+		path: string,
+		input: unknown,
+		isQuery: boolean,
+	): Observable<LensResult> {
+		return {
+			subscribe: (observer) => {
+				let cancelled = false;
+				let currentState: unknown;
+				let lastEmittedResult: unknown;
+				const cleanups: (() => void)[] = [];
+
+				// Helper to emit only if value changed
+				const emitIfChanged = (data: unknown) => {
+					if (cancelled) return;
+					if (valuesEqual(data, lastEmittedResult)) return;
+					lastEmittedResult = data;
+					observer.next?.({ data });
+				};
+
+				// Run the operation
+				(async () => {
+					try {
+						const def = isQuery ? this.queries[path] : this.mutations[path];
+						if (!def) {
+							observer.next?.({ error: new Error(`Operation not found: ${path}`) });
+							observer.complete?.();
+							return;
+						}
+
+						// Extract $select from input for queries
+						let select: SelectionObject | undefined;
+						let cleanInput = input;
+						if (isQuery && input && typeof input === "object" && "$select" in input) {
+							const { $select, ...rest } = input as Record<string, unknown>;
+							select = $select as SelectionObject;
+							cleanInput = Object.keys(rest).length > 0 ? rest : undefined;
+						}
+
+						// Validate input
+						if (def._input && cleanInput !== undefined) {
+							const result = def._input.safeParse(cleanInput);
+							if (!result.success) {
+								observer.next?.({
+									error: new Error(`Invalid input: ${JSON.stringify(result.error)}`),
+								});
+								observer.complete?.();
+								return;
+							}
+						}
+
+						const context = await this.contextFactory();
+
+						await runWithContext(this.ctx, context, async () => {
+							const resolver = def._resolve;
+							if (!resolver) {
+								observer.next?.({ error: new Error(`Operation ${path} has no resolver`) });
+								observer.complete?.();
+								return;
+							}
+
+							// Create emit handler with async queue processing
+							// Emit commands are queued and processed through processQueryResult
+							// to ensure field resolvers run on every emit
+							let emitProcessing = false;
+							const emitQueue: EmitCommand[] = [];
+
+							const processEmitQueue = async () => {
+								if (emitProcessing || cancelled) return;
+								emitProcessing = true;
+
+								while (emitQueue.length > 0 && !cancelled) {
+									const command = emitQueue.shift()!;
+									currentState = this.applyEmitCommand(command, currentState);
+
+									// Process through field resolvers (unlike before where we bypassed this)
+									// Note: createFieldEmit is created after this function but used lazily
+									const fieldEmitFactory = isQuery
+										? this.createFieldEmitFactory(
+												() => currentState,
+												(state) => {
+													currentState = state;
+												},
+												emitIfChanged,
+												select,
+												context,
+												onCleanup,
+											)
+										: undefined;
+
+									const processed = isQuery
+										? await this.processQueryResult(
+												path,
+												currentState,
+												select,
+												context,
+												onCleanup,
+												fieldEmitFactory,
+											)
+										: currentState;
+
+									emitIfChanged(processed);
+								}
+
+								emitProcessing = false;
+							};
+
+							const emitHandler = (command: EmitCommand) => {
+								if (cancelled) return;
+								emitQueue.push(command);
+								// Fire async processing (don't await - emit should be sync from caller's perspective)
+								processEmitQueue().catch((err) => {
+									if (!cancelled) {
+										observer.next?.({ error: err instanceof Error ? err : new Error(String(err)) });
+									}
+								});
+							};
+
+							const emit = createEmit(emitHandler);
+							const onCleanup = (fn: () => void) => {
+								cleanups.push(fn);
+								return () => {
+									const idx = cleanups.indexOf(fn);
+									if (idx >= 0) cleanups.splice(idx, 1);
+								};
+							};
+
+							// Create field emit factory for field-level live queries
+							const createFieldEmit = isQuery
+								? this.createFieldEmitFactory(
+										() => currentState,
+										(state) => {
+											currentState = state;
+										},
+										emitIfChanged,
+										select,
+										context,
+										onCleanup,
+									)
+								: undefined;
+
+							const lensContext = { ...context, emit, onCleanup };
+							const result = resolver({ input: cleanInput, ctx: lensContext });
+
+							if (isAsyncIterable(result)) {
+								// Streaming: emit each yielded value
+								for await (const value of result) {
+									if (cancelled) break;
+									currentState = value;
+									const processed = await this.processQueryResult(
+										path,
+										value,
+										select,
+										context,
+										onCleanup,
+										createFieldEmit,
+									);
+									emitIfChanged(processed);
+								}
+								if (!cancelled) {
+									observer.complete?.();
+								}
+							} else {
+								// One-shot: emit single value
+								const value = await result;
+								currentState = value;
+								const processed = isQuery
+									? await this.processQueryResult(
+											path,
+											value,
+											select,
+											context,
+											onCleanup,
+											createFieldEmit,
+										)
+									: value;
+								emitIfChanged(processed);
+								// Don't complete immediately - stay open for potential emit calls
+								// For true one-shot, client can unsubscribe after first value
+							}
+						});
+					} catch (error) {
+						if (!cancelled) {
+							observer.next?.({ error: error instanceof Error ? error : new Error(String(error)) });
+							observer.complete?.();
+						}
+					} finally {
+						this.clearLoaders();
+					}
+				})();
+
+				return {
+					unsubscribe: () => {
+						cancelled = true;
+						for (const fn of cleanups) {
+							fn();
+						}
+					},
+				};
+			},
+		};
+	}
 
-				const result = resolver({ input: cleanInput as TInput, ctx: lensContext });
+	/**
+	 * Apply emit command to current state.
+	 */
+	private applyEmitCommand(command: EmitCommand, state: unknown): unknown {
+		switch (command.type) {
+			case "full":
+				if (command.replace) {
+					return command.data;
+				}
+				// Merge mode
+				if (state && typeof state === "object" && typeof command.data === "object") {
+					return { ...state, ...(command.data as Record<string, unknown>) };
+				}
+				return command.data;
+
+			case "field":
+				if (state && typeof state === "object") {
+					return {
+						...(state as Record<string, unknown>),
+						[command.field]: command.update.data,
+					};
+				}
+				return { [command.field]: command.update.data };
 
-				let data: TOutput;
-				if (isAsyncIterable(result)) {
-					for await (const value of result) {
-						data = value as TOutput;
-						break;
+			case "batch":
+				if (state && typeof state === "object") {
+					const result = { ...(state as Record<string, unknown>) };
+					for (const update of command.updates) {
+						result[update.field] = update.update.data;
 					}
-					if (data! === undefined) {
-						throw new Error(`Query ${name} returned empty stream`);
-					}
-				} else {
-					data = (await result) as TOutput;
+					return result;
+				}
+				return state;
+
+			case "array": {
+				// Array operations - simplified handling
+				const arr = Array.isArray(state) ? [...state] : [];
+				const op = command.operation;
+				switch (op.op) {
+					case "push":
+						return [...arr, op.item];
+					case "unshift":
+						return [op.item, ...arr];
+					case "insert":
+						arr.splice(op.index, 0, op.item);
+						return arr;
+					case "remove":
+						arr.splice(op.index, 1);
+						return arr;
+					case "update":
+						arr[op.index] = op.item;
+						return arr;
+					default:
+						return arr;
 				}
+			}
 
-				return this.processQueryResult(name, data, select);
-			});
-		} finally {
-			this.clearLoaders();
+			default:
+				return state;
 		}
 	}
 
-	private async executeMutation<TInput, TOutput>(name: string, input: TInput): Promise<TOutput> {
-		const mutationDef = this.mutations[name];
-		if (!mutationDef) throw new Error(`Mutation not found: ${name}`);
-
-		// Validate input
-		if (mutationDef._input) {
-			const result = mutationDef._input.safeParse(input);
-			if (!result.success) {
-				throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
-			}
-		}
-
-		const context = await this.contextFactory();
+	// =========================================================================
+	// Result Processing
+	// =========================================================================
 
-		try {
-			return await runWithContext(this.ctx, context, async () => {
-				const resolver = mutationDef._resolve;
-				if (!resolver) throw new Error(`Mutation ${name} has no resolver`);
+	/**
+	 * Factory type for creating field-level emit handlers.
+	 * Each field gets its own emit that updates just that field path.
+	 */
+	private createFieldEmitFactory(
+		getCurrentState: () => unknown,
+		setCurrentState: (state: unknown) => void,
+		notifyObserver: (data: unknown) => void,
+		select: SelectionObject | undefined,
+		context: TContext | undefined,
+		onCleanup: ((fn: () => void) => void) | undefined,
+	): (fieldPath: string) => ((value: unknown) => void) | undefined {
+		return (fieldPath: string) => {
+			if (!fieldPath) return undefined;
+
+			return (newValue: unknown) => {
+				// Get current state and update the field at the given path
+				const state = getCurrentState();
+				if (!state || typeof state !== "object") return;
+
+				const updatedState = this.setFieldByPath(
+					state as Record<string, unknown>,
+					fieldPath,
+					newValue,
+				);
+				setCurrentState(updatedState);
+
+				// Resolve nested fields on the new value and notify observer
+				(async () => {
+					try {
+						const nestedInputs = select ? extractNestedInputs(select) : undefined;
+						const processed = await this.resolveEntityFields(
+							updatedState,
+							nestedInputs,
+							context,
+							"",
+							onCleanup,
+							this.createFieldEmitFactory(
+								getCurrentState,
+								setCurrentState,
+								notifyObserver,
+								select,
+								context,
+								onCleanup,
+							),
+						);
+						const result = select ? applySelection(processed, select) : processed;
+						notifyObserver(result);
+					} catch (err) {
+						// Field emit errors are logged but don't break the stream
+						console.error(`Field emit error at path "${fieldPath}":`, err);
+					}
+				})();
+			};
+		};
+	}
 
-				const emit = createEmit(() => {});
-				const onCleanup = () => () => {};
-				const lensContext = { ...context, emit, onCleanup };
+	/**
+	 * Set a value at a nested path in an object.
+	 * Creates a shallow copy at each level.
+	 */
+	private setFieldByPath(
+		obj: Record<string, unknown>,
+		path: string,
+		value: unknown,
+	): Record<string, unknown> {
+		const parts = path.split(".");
+		if (parts.length === 1) {
+			return { ...obj, [path]: value };
+		}
 
-				return (await resolver({ input: input as TInput, ctx: lensContext })) as TOutput;
-			});
-		} finally {
-			this.clearLoaders();
+		const [first, ...rest] = parts;
+		const nested = obj[first];
+		if (nested && typeof nested === "object") {
+			return {
+				...obj,
+				[first]: this.setFieldByPath(nested as Record<string, unknown>, rest.join("."), value),
+			};
 		}
+		return obj;
 	}
 
-	// =========================================================================
-	// Result Processing
-	// =========================================================================
-
 	private async processQueryResult<T>(
 		_operationName: string,
 		data: T,
 		select?: SelectionObject,
+		context?: TContext,
+		onCleanup?: (fn: () => void) => void,
+		createFieldEmit?: (fieldPath: string) => ((value: unknown) => void) | undefined,
 	): Promise<T> {
 		if (!data) return data;
 
-		const processed = await this.resolveEntityFields(data);
+		// Extract nested inputs from selection for field resolver args
+		const nestedInputs = select ? extractNestedInputs(select) : undefined;
+
+		const processed = await this.resolveEntityFields(
+			data,
+			nestedInputs,
+			context,
+			"",
+			onCleanup,
+			createFieldEmit,
+		);
 		if (select) {
 			return applySelection(processed, select) as T;
 		}
 		return processed as T;
 	}
 
-	private async resolveEntityFields<T>(data: T): Promise<T> {
+	/**
+	 * Resolve entity fields using field resolvers.
+	 * Supports nested inputs for field-level arguments (like GraphQL).
+	 *
+	 * @param data - The data to resolve
+	 * @param nestedInputs - Map of field paths to their input args (from extractNestedInputs)
+	 * @param context - Request context to pass to field resolvers
+	 * @param fieldPath - Current path for nested field resolution
+	 * @param onCleanup - Cleanup registration for live query subscriptions
+	 * @param createFieldEmit - Factory for creating field-specific emit handlers
+	 */
+	private async resolveEntityFields<T>(
+		data: T,
+		nestedInputs?: Map<string, Record<string, unknown>>,
+		context?: TContext,
+		fieldPath = "",
+		onCleanup?: (fn: () => void) => void,
+		createFieldEmit?: (fieldPath: string) => ((value: unknown) => void) | undefined,
+	): Promise<T> {
 		if (!data || !this.resolverMap) return data;
 
 		if (Array.isArray(data)) {
-			return Promise.all(data.map((item) => this.resolveEntityFields(item))) as Promise<T>;
+			return Promise.all(
+				data.map((item) =>
+					this.resolveEntityFields(
+						item,
+						nestedInputs,
+						context,
+						fieldPath,
+						onCleanup,
+						createFieldEmit,
+					),
+				),
+			) as Promise<T>;
 		}
 
 		if (typeof data !== "object") return data;
@@ -340,37 +657,107 @@ class LensServerImpl<
 			// Skip exposed fields
 			if (resolverDef.isExposed(field)) continue;
 
+			// Calculate the path for this field (for nested input lookup)
+			const currentPath = fieldPath ? `${fieldPath}.${field}` : field;
+
+			// Get args for this field from nested inputs
+			const args = nestedInputs?.get(currentPath) ?? {};
+			const hasArgs = Object.keys(args).length > 0;
+
 			// Skip if value already exists
 			const existingValue = result[field];
 			if (existingValue !== undefined) {
-				result[field] = await this.resolveEntityFields(existingValue);
+				result[field] = await this.resolveEntityFields(
+					existingValue,
+					nestedInputs,
+					context,
+					currentPath,
+					onCleanup,
+					createFieldEmit,
+				);
 				continue;
 			}
 
 			// Resolve the field
-			const loaderKey = `${typeName}.${field}`;
-			const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field);
-			result[field] = await loader.load(obj);
-			result[field] = await this.resolveEntityFields(result[field]);
+			if (hasArgs || context) {
+				// Direct resolution when we have args or context (skip DataLoader)
+				try {
+					// Build extended context with emit and onCleanup
+					// Lens is a live query library - these are always available
+					const extendedCtx = {
+						...(context ?? {}),
+						emit: createFieldEmit!(currentPath),
+						onCleanup: onCleanup!,
+					};
+					result[field] = await resolverDef.resolveField(field, obj, args, extendedCtx);
+				} catch {
+					result[field] = null;
+				}
+			} else {
+				// Use DataLoader for batching when no args (default case)
+				const loaderKey = `${typeName}.${field}`;
+				const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field);
+				result[field] = await loader.load(obj);
+			}
+
+			// Recursively resolve nested fields
+			result[field] = await this.resolveEntityFields(
+				result[field],
+				nestedInputs,
+				context,
+				currentPath,
+				onCleanup,
+				createFieldEmit,
+			);
 		}
 
 		return result as T;
 	}
 
+	/**
+	 * Get the type name for an object by matching against entity definitions.
+	 *
+	 * Matching priority:
+	 * 1. Explicit __typename or _type property
+	 * 2. Best matching entity (highest field overlap score)
+	 *
+	 * Requires at least 50% field match to avoid false positives.
+	 */
 	private getTypeName(obj: Record<string, unknown>): string | undefined {
+		// Priority 1: Explicit type marker
 		if ("__typename" in obj) return obj.__typename as string;
 		if ("_type" in obj) return obj._type as string;
 
+		// Priority 2: Find best matching entity by field overlap
+		let bestMatch: { name: string; score: number } | undefined;
+
 		for (const [name, def] of Object.entries(this.entities)) {
-			if (isEntityDef(def) && this.matchesEntity(obj, def)) {
-				return name;
+			if (!isEntityDef(def)) continue;
+
+			const score = this.getEntityMatchScore(obj, def);
+			// Require at least 50% field match to avoid false positives
+			if (score >= 0.5 && (!bestMatch || score > bestMatch.score)) {
+				bestMatch = { name, score };
 			}
 		}
-		return undefined;
+
+		return bestMatch?.name;
 	}
 
-	private matchesEntity(obj: Record<string, unknown>, entityDef: EntityDef<string, any>): boolean {
-		return "id" in obj || entityDef._name! in obj;
+	/**
+	 * Calculate how well an object matches an entity definition.
+	 *
+	 * @returns Score between 0 and 1 (1 = perfect match, all entity fields present)
+	 */
+	private getEntityMatchScore(
+		obj: Record<string, unknown>,
+		entityDef: EntityDef<string, any>,
+	): number {
+		const fieldNames = Object.keys(entityDef.fields);
+		if (fieldNames.length === 0) return 0;
+
+		const matchingFields = fieldNames.filter((field) => field in obj);
+		return matchingFields.length / fieldNames.length;
 	}
 
 	private getOrCreateLoaderForField(