@sylphx/lens-server 2.3.2 → 2.4.1

package/src/server/create.test.ts

@@ -1076,3 +1076,201 @@ describe("field resolvers", () => {
 		subscription.unsubscribe();
 	});
 });
+
+// =============================================================================
+// Observable Completion Tests
+// =============================================================================
+
+describe("observable behavior", () => {
+	it("delivers initial result immediately for queries", async () => {
+		const simpleQuery = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Test" }));
+
+		const server = createApp({ queries: { simpleQuery } });
+
+		const result = await firstValueFrom(
+			server.execute({
+				path: "simpleQuery",
+				input: { id: "1" },
+			}),
+		);
+
+		expect(result.data).toEqual({ id: "1", name: "Test" });
+		expect(result.error).toBeUndefined();
+	});
+
+	it("keeps subscription open for potential emit", async () => {
+		type EmitFn = (data: unknown) => void;
+		let capturedEmit: EmitFn | undefined;
+
+		const liveQuery = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input, ctx }) => {
+				capturedEmit = ctx.emit as EmitFn;
+				return { id: input.id, name: "Initial" };
+			});
+
+		const server = createApp({ queries: { liveQuery } });
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "liveQuery",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (value) => results.push(value),
+			});
+
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(1);
+
+		// Emit should still work (subscription is open)
+		capturedEmit!({ id: "1", name: "Updated" });
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(results.length).toBe(2);
+		subscription.unsubscribe();
+	});
+
+	it("delivers mutation result via observable", async () => {
+		const testMutation = mutation()
+			.input(z.object({ name: z.string() }))
+			.resolve(({ input }) => ({ id: "new", name: input.name }));
+
+		const server = createApp({ mutations: { testMutation } });
+
+		const result = await firstValueFrom(
+			server.execute({
+				path: "testMutation",
+				input: { name: "Test" },
+			}),
+		);
+
+		expect(result.data).toEqual({ id: "new", name: "Test" });
+	});
+
+	it("can be unsubscribed", async () => {
+		let resolverCalls = 0;
+
+		const simpleQuery = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => {
+				resolverCalls++;
+				return { id: input.id };
+			});
+
+		const server = createApp({ queries: { simpleQuery } });
+
+		const subscription = server
+			.execute({
+				path: "simpleQuery",
+				input: { id: "1" },
+			})
+			.subscribe({});
+
+		await new Promise((r) => setTimeout(r, 50));
+		subscription.unsubscribe();
+
+		// Should have been called exactly once
+		expect(resolverCalls).toBe(1);
+	});
+});
+
+// =============================================================================
+// Backpressure Tests
+// =============================================================================
+
+describe("emit backpressure", () => {
+	it("handles rapid emit calls without losing data", async () => {
+		type EmitFn = (data: unknown) => void;
+		let capturedEmit: EmitFn | undefined;
+
+		const liveQuery = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input, ctx }) => {
+				capturedEmit = ctx.emit as EmitFn;
+				return { id: input.id, count: 0 };
+			});
+
+		const server = createApp({ queries: { liveQuery } });
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "liveQuery",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (value) => results.push(value),
+			});
+
+		await new Promise((r) => setTimeout(r, 50));
+
+		// Rapidly emit many values
+		for (let i = 1; i <= 10; i++) {
+			capturedEmit!({ id: "1", count: i });
+		}
+
+		// Wait for all emits to process
+		await new Promise((r) => setTimeout(r, 100));
+
+		// Should have received all unique values
+		// Note: deduplication may reduce count if emit is too fast
+		expect(results.length).toBeGreaterThan(1);
+
+		// The last result should have count = 10
+		const lastResult = results[results.length - 1] as { data: { count: number } };
+		expect(lastResult.data.count).toBe(10);
+
+		subscription.unsubscribe();
+	});
+});
+
+// =============================================================================
+// Observable Error Handling Tests
+// =============================================================================
+
+describe("observable error handling", () => {
+	it("propagates resolver errors to observer", async () => {
+		const errorQuery = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(() => {
+				throw new Error("Test error");
+			});
+
+		const server = createApp({ queries: { errorQuery } });
+
+		const result = await firstValueFrom(
+			server.execute({
+				path: "errorQuery",
+				input: { id: "1" },
+			}),
+		);
+
+		expect(result.error).toBeDefined();
+		expect(result.error?.message).toBe("Test error");
+	});
+
+	it("handles async resolver errors", async () => {
+		const asyncErrorQuery = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(async () => {
+				await new Promise((r) => setTimeout(r, 10));
+				throw new Error("Async error");
+			});
+
+		const server = createApp({ queries: { asyncErrorQuery } });
+
+		const result = await firstValueFrom(
+			server.execute({
+				path: "asyncErrorQuery",
+				input: { id: "1" },
+			}),
+		);
+
+		expect(result.error).toBeDefined();
+		expect(result.error?.message).toBe("Async error");
+	});
+});

package/src/server/create.ts

@@ -21,6 +21,7 @@ import {
 	type EmitCommand,
 	type EntityDef,
 	flattenRouter,
+	hashValue,
 	type InferRouterContext,
 	isEntityDef,
 	isMutationDef,
@@ -31,7 +32,7 @@ import {
 	toResolverMap,
 	valuesEqual,
 } from "@sylphx/lens-core";
-import { createContext, runWithContext } from "../context/index.js";
+import { createContext, runWithContext, tryUseContext } from "../context/index.js";
 import {
 	createPluginManager,
 	type PluginManager,
@@ -92,6 +93,54 @@ function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
 	return value != null && typeof value === "object" && Symbol.asyncIterator in value;
 }
 
+/**
+ * Ring buffer with O(1) enqueue/dequeue operations.
+ * Used for emit queue to avoid O(n) Array.shift() performance issues.
+ */
+class RingBuffer<T> {
+	private buffer: (T | null)[];
+	private head = 0; // Points to first element to dequeue
+	private tail = 0; // Points to where to enqueue next
+	private count = 0;
+
+	constructor(private capacity: number) {
+		this.buffer = new Array(capacity).fill(null);
+	}
+
+	get size(): number {
+		return this.count;
+	}
+
+	get isEmpty(): boolean {
+		return this.count === 0;
+	}
+
+	/** Enqueue item. If at capacity, drops oldest item (returns true if dropped). */
+	enqueue(item: T): boolean {
+		let dropped = false;
+		if (this.count >= this.capacity) {
+			// Drop oldest (backpressure)
+			this.head = (this.head + 1) % this.capacity;
+			this.count--;
+			dropped = true;
+		}
+		this.buffer[this.tail] = item;
+		this.tail = (this.tail + 1) % this.capacity;
+		this.count++;
+		return dropped;
+	}
+
+	/** Dequeue and return item, or null if empty. */
+	dequeue(): T | null {
+		if (this.count === 0) return null;
+		const item = this.buffer[this.head];
+		this.buffer[this.head] = null; // Allow GC
+		this.head = (this.head + 1) % this.capacity;
+		this.count--;
+		return item;
+	}
+}
+
 // =============================================================================
 // Server Implementation
 // =============================================================================
@@ -247,13 +296,22 @@ class LensServerImpl<
 				let cancelled = false;
 				let currentState: unknown;
 				let lastEmittedResult: unknown;
+				let lastEmittedHash: string | undefined;
 				const cleanups: (() => void)[] = [];
 
 				// Helper to emit only if value changed
+				// Uses cached hash for O(1) comparison after first call
 				const emitIfChanged = (data: unknown) => {
 					if (cancelled) return;
-					if (valuesEqual(data, lastEmittedResult)) return;
+					const dataHash = hashValue(data);
+					if (
+						lastEmittedHash !== undefined &&
+						valuesEqual(data, lastEmittedResult, dataHash, lastEmittedHash)
+					) {
+						return;
+					}
 					lastEmittedResult = data;
+					lastEmittedHash = dataHash;
 					observer.next?.({ data });
 				};
 
@@ -302,14 +360,15 @@ class LensServerImpl<
 							// Emit commands are queued and processed through processQueryResult
 							// to ensure field resolvers run on every emit
 							let emitProcessing = false;
-							const emitQueue: EmitCommand[] = [];
+							const MAX_EMIT_QUEUE_SIZE = 100; // Backpressure: prevent memory bloat
+							const emitQueue = new RingBuffer<EmitCommand>(MAX_EMIT_QUEUE_SIZE);
 
 							const processEmitQueue = async () => {
 								if (emitProcessing || cancelled) return;
 								emitProcessing = true;
 
-								while (emitQueue.length > 0 && !cancelled) {
-									const command = emitQueue.shift()!;
+								let command = emitQueue.dequeue();
+								while (command !== null && !cancelled) {
 									currentState = this.applyEmitCommand(command, currentState);
 
 									// Process through field resolvers (unlike before where we bypassed this)
@@ -339,6 +398,7 @@ class LensServerImpl<
 										: currentState;
 
 									emitIfChanged(processed);
+									command = emitQueue.dequeue();
 								}
 
 								emitProcessing = false;
@@ -346,7 +406,10 @@ class LensServerImpl<
 
 							const emitHandler = (command: EmitCommand) => {
 								if (cancelled) return;
-								emitQueue.push(command);
+
+								// Enqueue command - RingBuffer handles backpressure automatically
+								// (drops oldest if at capacity, which is correct for live queries)
+								emitQueue.enqueue(command);
 								// Fire async processing (don't await - emit should be sync from caller's perspective)
 								processEmitQueue().catch((err) => {
 									if (!cancelled) {
@@ -416,8 +479,12 @@ class LensServerImpl<
 										)
 									: value;
 								emitIfChanged(processed);
-								// Don't complete immediately - stay open for potential emit calls
-								// For true one-shot, client can unsubscribe after first value
+
+								// Mutations complete immediately - they're truly one-shot
+								// Queries stay open for potential emit calls from field resolvers
+								if (!isQuery && !cancelled) {
+									observer.complete?.();
+								}
 							}
 						});
 					} catch (error) {
@@ -781,6 +848,8 @@ class LensServerImpl<
 		let loader = this.loaders.get(loaderKey);
 		if (!loader) {
 			loader = new DataLoader(async (parents: unknown[]) => {
+				// Get context from AsyncLocalStorage - maintains request context in batched calls
+				const context = tryUseContext<TContext>() ?? ({} as TContext);
 				const results: unknown[] = [];
 				for (const parent of parents) {
 					try {
@@ -788,7 +857,7 @@ class LensServerImpl<
 							fieldName,
 							parent as Record<string, unknown>,
 							{},
-							{},
+							context,
 						);
 						results.push(result);
 					} catch {

package/src/server/types.ts

@@ -152,7 +152,7 @@ export type ClientSendFn = (message: unknown) => void;
 /** WebSocket interface for adapters */
 export interface WebSocketLike {
 	send(data: string): void;
-	close(): void;
+	close(code?: number, reason?: string): void;
 	onmessage?: ((event: { data: string }) => void) | null;
 	onclose?: (() => void) | null;
 	onerror?: ((error: unknown) => void) | null;