@sylphx/lens-server 2.2.0 → 2.3.1

package/src/server/create.ts

@@ -29,6 +29,7 @@ import {
 	type ResolverDef,
 	type RouterDef,
 	toResolverMap,
+	valuesEqual,
 } from "@sylphx/lens-core";
 import { createContext, runWithContext } from "../context/index.js";
 import {
@@ -41,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,
@@ -234,8 +235,17 @@ class LensServerImpl<
 			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 {
@@ -277,14 +287,66 @@ class LensServerImpl<
 								return;
 							}
 
-							// Create emit handler that pushes to observer
+							// 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;
-								currentState = this.applyEmitCommand(command, currentState);
-								observer.next?.({ data: currentState });
+								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);
+							// Detect array output type: [EntityDef] is stored as single-element array
+							const isArrayOutput = Array.isArray(def._output);
+							const emit = createEmit(emitHandler, isArrayOutput);
 							const onCleanup = (fn: () => void) => {
 								cleanups.push(fn);
 								return () => {
@@ -293,6 +355,20 @@ class LensServerImpl<
 								};
 							};
 
+							// 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 });
 
@@ -301,8 +377,15 @@ class LensServerImpl<
 								for await (const value of result) {
 									if (cancelled) break;
 									currentState = value;
-									const processed = await this.processQueryResult(path, value, select);
-									observer.next?.({ data: processed });
+									const processed = await this.processQueryResult(
+										path,
+										value,
+										select,
+										context,
+										onCleanup,
+										createFieldEmit,
+									);
+									emitIfChanged(processed);
 								}
 								if (!cancelled) {
 									observer.complete?.();
@@ -312,13 +395,18 @@ class LensServerImpl<
 								const value = await result;
 								currentState = value;
 								const processed = isQuery
-									? await this.processQueryResult(path, value, select)
+									? await this.processQueryResult(
+											path,
+											value,
+											select,
+											context,
+											onCleanup,
+											createFieldEmit,
+										)
 									: value;
-								if (!cancelled) {
-									observer.next?.({ data: processed });
-									// Don't complete immediately - stay open for potential emit calls
-									// For true one-shot, client can unsubscribe after first 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) {
@@ -409,25 +497,149 @@ class LensServerImpl<
 	// Result Processing
 	// =========================================================================
 
+	/**
+	 * 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);
+					}
+				})();
+			};
+		};
+	}
+
+	/**
+	 * 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 };
+		}
+
+		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;
+	}
+
 	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;
@@ -447,37 +659,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(

package/src/server/selection.test.ts

@@ -0,0 +1,253 @@
+/**
+ * @sylphx/lens-server - Selection Tests
+ *
+ * Tests for field selection and nested input extraction.
+ */
+
+import { describe, expect, it } from "bun:test";
+import { applySelection, extractNestedInputs } from "./selection.js";
+
+// =============================================================================
+// applySelection Tests
+// =============================================================================
+
+describe("applySelection", () => {
+	it("selects simple fields", () => {
+		const data = { id: "1", name: "Alice", email: "alice@example.com", age: 30 };
+		const select = { name: true, email: true };
+
+		const result = applySelection(data, select);
+
+		expect(result).toEqual({ id: "1", name: "Alice", email: "alice@example.com" });
+	});
+
+	it("always includes id field", () => {
+		const data = { id: "1", name: "Alice" };
+		const select = { name: true };
+
+		const result = applySelection(data, select);
+
+		expect(result).toEqual({ id: "1", name: "Alice" });
+	});
+
+	it("handles nested selection with { select: ... }", () => {
+		const data = {
+			id: "1",
+			name: "Alice",
+			profile: { avatar: "url", bio: "Hello" },
+		};
+		const select = {
+			name: true,
+			profile: { select: { avatar: true } },
+		};
+
+		const result = applySelection(data, select);
+
+		expect(result).toEqual({
+			id: "1",
+			name: "Alice",
+			profile: { avatar: "url" },
+		});
+	});
+
+	it("handles nested selection with { input: ..., select: ... }", () => {
+		const data = {
+			id: "1",
+			name: "Alice",
+			posts: [
+				{ id: "p1", title: "Post 1" },
+				{ id: "p2", title: "Post 2" },
+			],
+		};
+		const select = {
+			name: true,
+			posts: {
+				input: { limit: 5 }, // input is ignored for selection, used for resolver args
+				select: { title: true },
+			},
+		};
+
+		const result = applySelection(data, select);
+
+		expect(result).toEqual({
+			id: "1",
+			name: "Alice",
+			posts: [
+				{ id: "p1", title: "Post 1" },
+				{ id: "p2", title: "Post 2" },
+			],
+		});
+	});
+
+	it("handles arrays", () => {
+		const data = [
+			{ id: "1", name: "Alice", email: "alice@example.com" },
+			{ id: "2", name: "Bob", email: "bob@example.com" },
+		];
+		const select = { name: true };
+
+		const result = applySelection(data, select);
+
+		expect(result).toEqual([
+			{ id: "1", name: "Alice" },
+			{ id: "2", name: "Bob" },
+		]);
+	});
+
+	it("returns null/undefined as-is", () => {
+		expect(applySelection(null, { name: true })).toBeNull();
+		expect(applySelection(undefined, { name: true })).toBeUndefined();
+	});
+
+	it("includes whole field when no nested select", () => {
+		const data = {
+			id: "1",
+			profile: { avatar: "url", bio: "Hello" },
+		};
+		const select = {
+			profile: { input: { size: "large" } }, // input only, no select
+		};
+
+		const result = applySelection(data, select);
+
+		expect(result).toEqual({
+			id: "1",
+			profile: { avatar: "url", bio: "Hello" },
+		});
+	});
+});
+
+// =============================================================================
+// extractNestedInputs Tests
+// =============================================================================
+
+describe("extractNestedInputs", () => {
+	it("extracts input from nested selection", () => {
+		const select = {
+			name: true,
+			posts: {
+				input: { limit: 5, published: true },
+				select: { title: true },
+			},
+		};
+
+		const inputs = extractNestedInputs(select);
+
+		expect(inputs.size).toBe(1);
+		expect(inputs.get("posts")).toEqual({ limit: 5, published: true });
+	});
+
+	it("extracts inputs at multiple levels", () => {
+		const select = {
+			name: true,
+			posts: {
+				input: { limit: 5 },
+				select: {
+					title: true,
+					comments: {
+						input: { limit: 3 },
+						select: { body: true },
+					},
+				},
+			},
+		};
+
+		const inputs = extractNestedInputs(select);
+
+		expect(inputs.size).toBe(2);
+		expect(inputs.get("posts")).toEqual({ limit: 5 });
+		expect(inputs.get("posts.comments")).toEqual({ limit: 3 });
+	});
+
+	it("returns empty map when no nested inputs", () => {
+		const select = {
+			name: true,
+			posts: { select: { title: true } },
+		};
+
+		const inputs = extractNestedInputs(select);
+
+		expect(inputs.size).toBe(0);
+	});
+
+	it("handles deeply nested inputs", () => {
+		const select = {
+			author: {
+				input: { includeDeleted: false },
+				select: {
+					posts: {
+						input: { status: "published" },
+						select: {
+							comments: {
+								input: { limit: 10 },
+								select: {
+									replies: {
+										input: { depth: 2 },
+										select: { body: true },
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		};
+
+		const inputs = extractNestedInputs(select);
+
+		expect(inputs.size).toBe(4);
+		expect(inputs.get("author")).toEqual({ includeDeleted: false });
+		expect(inputs.get("author.posts")).toEqual({ status: "published" });
+		expect(inputs.get("author.posts.comments")).toEqual({ limit: 10 });
+		expect(inputs.get("author.posts.comments.replies")).toEqual({ depth: 2 });
+	});
+
+	it("handles mixed selection (some with input, some without)", () => {
+		const select = {
+			name: true,
+			posts: {
+				input: { limit: 5 },
+				select: { title: true },
+			},
+			followers: {
+				select: { name: true }, // no input
+			},
+			settings: true, // simple selection
+		};
+
+		const inputs = extractNestedInputs(select);
+
+		expect(inputs.size).toBe(1);
+		expect(inputs.get("posts")).toEqual({ limit: 5 });
+		expect(inputs.has("followers")).toBe(false);
+		expect(inputs.has("settings")).toBe(false);
+	});
+
+	it("handles input with empty object", () => {
+		const select = {
+			posts: {
+				input: {},
+				select: { title: true },
+			},
+		};
+
+		const inputs = extractNestedInputs(select);
+
+		// Empty input object is still recorded
+		expect(inputs.size).toBe(1);
+		expect(inputs.get("posts")).toEqual({});
+	});
+
+	it("handles selection with input but no select", () => {
+		const select = {
+			posts: {
+				input: { limit: 5 },
+			},
+		};
+
+		const inputs = extractNestedInputs(select);
+
+		expect(inputs.size).toBe(1);
+		expect(inputs.get("posts")).toEqual({ limit: 5 });
+	});
+});