@sylphx/lens-server 1.5.6 → 1.11.0

package/dist/index.js

@@ -507,8 +507,8 @@ function sugarToPipeline(optimistic, entityType, inputFields) {
       $pipe: [{ $do: "entity.delete", $with: { type: entityType, id: { $input: "id" } } }]
     };
   }
-  if (typeof optimistic === "object" && optimistic !== null && "merge" in optimistic && typeof optimistic["merge"] === "object") {
-    const extra = optimistic["merge"];
+  if (typeof optimistic === "object" && optimistic !== null && "merge" in optimistic && typeof optimistic.merge === "object") {
+    const extra = optimistic.merge;
     const args = { type: entityType };
     for (const field of inputFields) {
       args[field] = { $input: field };
@@ -851,11 +851,14 @@ class LensServerImpl {
             sub.cleanups.splice(idx, 1);
         };
       };
-      const result = resolver({
-        input: sub.input,
-        ctx: context,
+      const lensContext = {
+        ...context,
         emit,
         onCleanup
+      };
+      const result = resolver({
+        input: sub.input,
+        ctx: lensContext
       });
       if (isAsyncIterable(result)) {
         for await (const value of result) {
@@ -1006,11 +1009,14 @@ class LensServerImpl {
         }
         const emit = createEmit(() => {});
         const onCleanup = () => () => {};
-        const result = resolver({
-          input: cleanInput,
-          ctx: context,
+        const lensContext = {
+          ...context,
           emit,
           onCleanup
+        };
+        const result = resolver({
+          input: cleanInput,
+          ctx: lensContext
         });
         let data;
         if (isAsyncIterable(result)) {
@@ -1050,11 +1056,14 @@ class LensServerImpl {
         }
         const emit = createEmit(() => {});
         const onCleanup = () => () => {};
-        const result = await resolver({
-          input,
-          ctx: context,
+        const lensContext = {
+          ...context,
           emit,
           onCleanup
+        };
+        const result = await resolver({
+          input,
+          ctx: lensContext
         });
         const entityName = this.getEntityNameFromMutation(name);
         const entities = this.extractEntities(entityName, result);
@@ -1209,7 +1218,7 @@ class LensServerImpl {
     const result = {};
     const obj = data;
     if ("id" in obj) {
-      result["id"] = obj["id"];
+      result.id = obj.id;
     }
     if (Array.isArray(fields)) {
       for (const field of fields) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "1.5.6",
+	"version": "1.11.0",
 	"description": "Server runtime for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -30,7 +30,7 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-core": "^1.15.0"
+		"@sylphx/lens-core": "^1.22.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.9.3",

package/src/e2e/server.test.ts

@@ -317,8 +317,8 @@ describe("E2E - Subscriptions", () => {
 		const watchUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, emit }) => {
-				emitFn = emit;
+			.resolve(({ input, ctx }) => {
+				emitFn = ctx.emit;
 				const user = mockUsers.find((u) => u.id === input.id);
 				if (!user) throw new Error("Not found");
 				return user;
@@ -362,8 +362,8 @@ describe("E2E - Subscriptions", () => {
 		const watchUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, emit }) => {
-				emitFn = emit;
+			.resolve(({ input, ctx }) => {
+				emitFn = ctx.emit;
 				const user = mockUsers.find((u) => u.id === input.id);
 				if (!user) throw new Error("Not found");
 				return user;
@@ -464,8 +464,8 @@ describe("E2E - Cleanup", () => {
 		const watchUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, onCleanup }) => {
-				onCleanup(() => {
+			.resolve(({ input, ctx }) => {
+				ctx.onCleanup(() => {
 					cleanedUp = true;
 				});
 				const user = mockUsers.find((u) => u.id === input.id);
@@ -506,8 +506,8 @@ describe("E2E - GraphStateManager", () => {
 		const getUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, emit }) => {
-				emitFn = emit;
+			.resolve(({ input, ctx }) => {
+				emitFn = ctx.emit;
 				const user = mockUsers.find((u) => u.id === input.id);
 				if (!user) throw new Error("Not found");
 				return user;

package/src/server/create.test.ts

@@ -724,8 +724,8 @@ describe("onCleanup", () => {
 
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ onCleanup }) => {
-				onCleanup(() => {
+			.resolve(({ ctx }) => {
+				ctx.onCleanup(() => {
 					cleanedUp = true;
 				});
 				return mockUsers[0];
@@ -764,8 +764,8 @@ describe("onCleanup", () => {
 
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ onCleanup }) => {
-				onCleanup(() => {
+			.resolve(({ ctx }) => {
+				ctx.onCleanup(() => {
 					cleanedUp = true;
 				});
 				return mockUsers[0];
@@ -802,8 +802,8 @@ describe("onCleanup", () => {
 
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ onCleanup }) => {
-				const remove = onCleanup(() => {
+			.resolve(({ ctx }) => {
+				const remove = ctx.onCleanup(() => {
 					cleanedUp = true;
 				});
 				// Remove the cleanup before unsubscribe
@@ -1515,8 +1515,8 @@ describe("Logger integration", () => {
 		const errorLogs: string[] = [];
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ onCleanup }) => {
-				onCleanup(() => {
+			.resolve(({ ctx }) => {
+				ctx.onCleanup(() => {
 					throw new Error("Cleanup failed");
 				});
 				return mockUsers[0];
@@ -1560,8 +1560,8 @@ describe("Logger integration", () => {
 		const errorLogs: string[] = [];
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ onCleanup }) => {
-				onCleanup(() => {
+			.resolve(({ ctx }) => {
+				ctx.onCleanup(() => {
 					throw new Error("Disconnect cleanup failed");
 				});
 				return mockUsers[0];
@@ -1600,6 +1600,567 @@ describe("Logger integration", () => {
 	});
 });
 
+// =============================================================================
+// Test: DataLoader Batching
+// =============================================================================
+
+describe("DataLoader Batching", () => {
+	it("batches multiple load calls into single batch function call", async () => {
+		let batchCallCount = 0;
+		let receivedKeys: string[] = [];
+
+		class TestDataLoader {
+			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
+			private scheduled = false;
+
+			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
+
+			async load(key: string): Promise<string | null> {
+				return new Promise((resolve, reject) => {
+					const existing = this.batch.get(key);
+					if (existing) {
+						existing.push({ resolve, reject });
+					} else {
+						this.batch.set(key, [{ resolve, reject }]);
+					}
+					this.scheduleDispatch();
+				});
+			}
+
+			private scheduleDispatch(): void {
+				if (this.scheduled) return;
+				this.scheduled = true;
+				queueMicrotask(() => this.dispatch());
+			}
+
+			private async dispatch(): Promise<void> {
+				this.scheduled = false;
+				const batch = this.batch;
+				this.batch = new Map();
+
+				const keys = Array.from(batch.keys());
+				if (keys.length === 0) return;
+
+				try {
+					const results = await this.batchFn(keys);
+					keys.forEach((key, index) => {
+						const callbacks = batch.get(key)!;
+						const result = results[index] ?? null;
+						for (const { resolve } of callbacks) resolve(result);
+					});
+				} catch (error) {
+					for (const callbacks of batch.values()) {
+						for (const { reject } of callbacks) reject(error as Error);
+					}
+				}
+			}
+
+			clear(): void {
+				this.batch.clear();
+			}
+		}
+
+		const loader = new TestDataLoader(async (keys) => {
+			batchCallCount++;
+			receivedKeys = keys;
+			return keys.map((k) => `value-${k}`);
+		});
+
+		// Load multiple keys in same tick
+		const promises = [loader.load("key1"), loader.load("key2"), loader.load("key3")];
+
+		const results = await Promise.all(promises);
+
+		// Should batch all calls into single batch function call
+		expect(batchCallCount).toBe(1);
+		expect(receivedKeys).toEqual(["key1", "key2", "key3"]);
+		expect(results).toEqual(["value-key1", "value-key2", "value-key3"]);
+	});
+
+	it("handles duplicate keys in same batch", async () => {
+		class TestDataLoader {
+			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
+			private scheduled = false;
+
+			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
+
+			async load(key: string): Promise<string | null> {
+				return new Promise((resolve, reject) => {
+					const existing = this.batch.get(key);
+					if (existing) {
+						existing.push({ resolve, reject });
+					} else {
+						this.batch.set(key, [{ resolve, reject }]);
+					}
+					this.scheduleDispatch();
+				});
+			}
+
+			private scheduleDispatch(): void {
+				if (this.scheduled) return;
+				this.scheduled = true;
+				queueMicrotask(() => this.dispatch());
+			}
+
+			private async dispatch(): Promise<void> {
+				this.scheduled = false;
+				const batch = this.batch;
+				this.batch = new Map();
+
+				const keys = Array.from(batch.keys());
+				if (keys.length === 0) return;
+
+				try {
+					const results = await this.batchFn(keys);
+					keys.forEach((key, index) => {
+						const callbacks = batch.get(key)!;
+						const result = results[index] ?? null;
+						for (const { resolve } of callbacks) resolve(result);
+					});
+				} catch (error) {
+					for (const callbacks of batch.values()) {
+						for (const { reject } of callbacks) reject(error as Error);
+					}
+				}
+			}
+
+			clear(): void {
+				this.batch.clear();
+			}
+		}
+
+		const loader = new TestDataLoader(async (keys) => {
+			return keys.map((k) => `value-${k}`);
+		});
+
+		// Load same key multiple times
+		const promises = [loader.load("key1"), loader.load("key1"), loader.load("key1")];
+
+		const results = await Promise.all(promises);
+
+		// All should resolve with same value
+		expect(results).toEqual(["value-key1", "value-key1", "value-key1"]);
+	});
+
+	it("handles batch function errors", async () => {
+		class TestDataLoader {
+			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
+			private scheduled = false;
+
+			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
+
+			async load(key: string): Promise<string | null> {
+				return new Promise((resolve, reject) => {
+					const existing = this.batch.get(key);
+					if (existing) {
+						existing.push({ resolve, reject });
+					} else {
+						this.batch.set(key, [{ resolve, reject }]);
+					}
+					this.scheduleDispatch();
+				});
+			}
+
+			private scheduleDispatch(): void {
+				if (this.scheduled) return;
+				this.scheduled = true;
+				queueMicrotask(() => this.dispatch());
+			}
+
+			private async dispatch(): Promise<void> {
+				this.scheduled = false;
+				const batch = this.batch;
+				this.batch = new Map();
+
+				const keys = Array.from(batch.keys());
+				if (keys.length === 0) return;
+
+				try {
+					const results = await this.batchFn(keys);
+					keys.forEach((key, index) => {
+						const callbacks = batch.get(key)!;
+						const result = results[index] ?? null;
+						for (const { resolve } of callbacks) resolve(result);
+					});
+				} catch (error) {
+					for (const callbacks of batch.values()) {
+						for (const { reject } of callbacks) reject(error as Error);
+					}
+				}
+			}
+
+			clear(): void {
+				this.batch.clear();
+			}
+		}
+
+		const loader = new TestDataLoader(async () => {
+			throw new Error("Batch function error");
+		});
+
+		const promises = [loader.load("key1"), loader.load("key2")];
+
+		// All loads should reject with same error
+		await expect(Promise.all(promises)).rejects.toThrow("Batch function error");
+	});
+
+	it("does not schedule dispatch twice if already scheduled", async () => {
+		let dispatchCount = 0;
+
+		class TestDataLoader {
+			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
+			private scheduled = false;
+
+			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
+
+			async load(key: string): Promise<string | null> {
+				return new Promise((resolve, reject) => {
+					const existing = this.batch.get(key);
+					if (existing) {
+						existing.push({ resolve, reject });
+					} else {
+						this.batch.set(key, [{ resolve, reject }]);
+					}
+					this.scheduleDispatch();
+				});
+			}
+
+			private scheduleDispatch(): void {
+				if (this.scheduled) return;
+				this.scheduled = true;
+				queueMicrotask(() => this.dispatch());
+			}
+
+			private async dispatch(): Promise<void> {
+				dispatchCount++;
+				this.scheduled = false;
+				const batch = this.batch;
+				this.batch = new Map();
+
+				const keys = Array.from(batch.keys());
+				if (keys.length === 0) return;
+
+				try {
+					const results = await this.batchFn(keys);
+					keys.forEach((key, index) => {
+						const callbacks = batch.get(key)!;
+						const result = results[index] ?? null;
+						for (const { resolve } of callbacks) resolve(result);
+					});
+				} catch (error) {
+					for (const callbacks of batch.values()) {
+						for (const { reject } of callbacks) reject(error as Error);
+					}
+				}
+			}
+
+			clear(): void {
+				this.batch.clear();
+			}
+		}
+
+		const loader = new TestDataLoader(async (keys) => {
+			return keys.map((k) => `value-${k}`);
+		});
+
+		// Load multiple keys
+		await Promise.all([loader.load("key1"), loader.load("key2"), loader.load("key3")]);
+
+		// Should only dispatch once despite multiple load calls
+		expect(dispatchCount).toBe(1);
+	});
+
+	it("clears pending batches when clear is called", () => {
+		class TestDataLoader {
+			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
+			private scheduled = false;
+
+			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
+
+			async load(key: string): Promise<string | null> {
+				return new Promise((resolve, reject) => {
+					const existing = this.batch.get(key);
+					if (existing) {
+						existing.push({ resolve, reject });
+					} else {
+						this.batch.set(key, [{ resolve, reject }]);
+					}
+					this.scheduleDispatch();
+				});
+			}
+
+			private scheduleDispatch(): void {
+				if (this.scheduled) return;
+				this.scheduled = true;
+				queueMicrotask(() => this.dispatch());
+			}
+
+			private async dispatch(): Promise<void> {
+				this.scheduled = false;
+				const batch = this.batch;
+				this.batch = new Map();
+
+				const keys = Array.from(batch.keys());
+				if (keys.length === 0) return;
+
+				try {
+					const results = await this.batchFn(keys);
+					keys.forEach((key, index) => {
+						const callbacks = batch.get(key)!;
+						const result = results[index] ?? null;
+						for (const { resolve } of callbacks) resolve(result);
+					});
+				} catch (error) {
+					for (const callbacks of batch.values()) {
+						for (const { reject } of callbacks) reject(error as Error);
+					}
+				}
+			}
+
+			clear(): void {
+				this.batch.clear();
+			}
+
+			getBatchSize(): number {
+				return this.batch.size;
+			}
+		}
+
+		const loader = new TestDataLoader(async (keys) => {
+			return keys.map((k) => `value-${k}`);
+		});
+
+		// Add some items to batch (but don't await - they won't dispatch yet)
+		loader.load("key1");
+		loader.load("key2");
+
+		// Clear should remove pending items
+		loader.clear();
+
+		// Batch should be empty
+		expect(loader.getBatchSize()).toBe(0);
+	});
+
+	it("handles null results from batch function", async () => {
+		class TestDataLoader {
+			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
+			private scheduled = false;
+
+			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
+
+			async load(key: string): Promise<string | null> {
+				return new Promise((resolve, reject) => {
+					const existing = this.batch.get(key);
+					if (existing) {
+						existing.push({ resolve, reject });
+					} else {
+						this.batch.set(key, [{ resolve, reject }]);
+					}
+					this.scheduleDispatch();
+				});
+			}
+
+			private scheduleDispatch(): void {
+				if (this.scheduled) return;
+				this.scheduled = true;
+				queueMicrotask(() => this.dispatch());
+			}
+
+			private async dispatch(): Promise<void> {
+				this.scheduled = false;
+				const batch = this.batch;
+				this.batch = new Map();
+
+				const keys = Array.from(batch.keys());
+				if (keys.length === 0) return;
+
+				try {
+					const results = await this.batchFn(keys);
+					keys.forEach((key, index) => {
+						const callbacks = batch.get(key)!;
+						const result = results[index] ?? null;
+						for (const { resolve } of callbacks) resolve(result);
+					});
+				} catch (error) {
+					for (const callbacks of batch.values()) {
+						for (const { reject } of callbacks) reject(error as Error);
+					}
+				}
+			}
+
+			clear(): void {
+				this.batch.clear();
+			}
+		}
+
+		const loader = new TestDataLoader(async (keys) => {
+			// Return null for some keys
+			return keys.map((k) => (k === "key2" ? null : `value-${k}`));
+		});
+
+		const results = await Promise.all([loader.load("key1"), loader.load("key2"), loader.load("key3")]);
+
+		expect(results).toEqual(["value-key1", null, "value-key3"]);
+	});
+});
+
+// =============================================================================
+// Test: HTTP Server Lifecycle (listen, close, findConnectionByWs)
+// =============================================================================
+
+describe("HTTP Server Lifecycle", () => {
+	it("handles GET requests that are not metadata endpoint", async () => {
+		const server = createServer({
+			entities: { User },
+		});
+
+		const request = new Request("http://localhost/some-other-path", { method: "GET" });
+		const response = await server.handleRequest(request);
+
+		expect(response.status).toBe(405);
+		const text = await response.text();
+		expect(text).toBe("Method not allowed");
+	});
+
+	it("handles PUT requests", async () => {
+		const server = createServer({
+			entities: { User },
+		});
+
+		const request = new Request("http://localhost/api", { method: "PUT" });
+		const response = await server.handleRequest(request);
+
+		expect(response.status).toBe(405);
+		const text = await response.text();
+		expect(text).toBe("Method not allowed");
+	});
+
+	it("handles DELETE requests", async () => {
+		const server = createServer({
+			entities: { User },
+		});
+
+		const request = new Request("http://localhost/api", { method: "DELETE" });
+		const response = await server.handleRequest(request);
+
+		expect(response.status).toBe(405);
+		const text = await response.text();
+		expect(text).toBe("Method not allowed");
+	});
+
+	it("handles PATCH requests", async () => {
+		const server = createServer({
+			entities: { User },
+		});
+
+		const request = new Request("http://localhost/api", { method: "PATCH" });
+		const response = await server.handleRequest(request);
+
+		expect(response.status).toBe(405);
+		const text = await response.text();
+		expect(text).toBe("Method not allowed");
+	});
+
+	it("handles OPTIONS requests", async () => {
+		const server = createServer({
+			entities: { User },
+		});
+
+		const request = new Request("http://localhost/api", { method: "OPTIONS" });
+		const response = await server.handleRequest(request);
+
+		expect(response.status).toBe(405);
+		const text = await response.text();
+		expect(text).toBe("Method not allowed");
+	});
+
+	it("handles HEAD requests", async () => {
+		const server = createServer({
+			entities: { User },
+		});
+
+		const request = new Request("http://localhost/api", { method: "HEAD" });
+		const response = await server.handleRequest(request);
+
+		expect(response.status).toBe(405);
+	});
+
+	it("can start and stop server with listen/close", async () => {
+		const server = createServer({
+			entities: { User },
+			logger: {
+				info: () => {}, // Silent logger for test
+			},
+		});
+
+		// Start server on a random high port to avoid conflicts
+		const port = 30000 + Math.floor(Math.random() * 10000);
+
+		try {
+			await server.listen(port);
+
+			// Verify server is running by making a request
+			const response = await fetch(`http://localhost:${port}/__lens/metadata`);
+			expect(response.status).toBe(200);
+			const data = await response.json();
+			expect(data.version).toBeDefined();
+		} finally {
+			// Always close the server
+			await server.close();
+		}
+	});
+
+	it("handles method not allowed via real HTTP server", async () => {
+		const server = createServer({
+			entities: { User },
+			logger: {
+				info: () => {}, // Silent logger for test
+			},
+		});
+
+		const port = 30000 + Math.floor(Math.random() * 10000);
+
+		try {
+			await server.listen(port);
+
+			// Make a PUT request which should return 405
+			const response = await fetch(`http://localhost:${port}/api`, { method: "PUT" });
+			expect(response.status).toBe(405);
+			const text = await response.text();
+			expect(text).toBe("Method not allowed");
+		} finally {
+			await server.close();
+		}
+	});
+
+	// Note: WebSocket integration via Bun.serve's native WebSocket upgrade (lines 1184-1193)
+	// is tested through unit tests using mock WebSockets. Full integration tests with real
+	// WebSocket clients would require additional setup and are better suited for E2E tests.
+});
+
+// =============================================================================
+// Test: SSE Handler Edge Cases
+// =============================================================================
+
+describe("SSE Handler Edge Cases", () => {
+	it("handles WebSocket error callback", async () => {
+		const server = createServer({
+			entities: { User },
+		});
+
+		const ws = createMockWs();
+		server.handleWebSocket(ws);
+
+		// Trigger error callback (if set)
+		if (ws.onerror) {
+			ws.onerror(new Error("WebSocket error"));
+		}
+
+		// Should not crash
+		expect(true).toBe(true);
+	});
+});
+
 // =============================================================================
 // Test: Entity Resolvers
 // =============================================================================

package/src/server/create.ts

@@ -248,9 +248,9 @@ function sugarToPipeline(
 		typeof optimistic === "object" &&
 		optimistic !== null &&
 		"merge" in optimistic &&
-		typeof (optimistic as Record<string, unknown>)["merge"] === "object"
+		typeof (optimistic as Record<string, unknown>).merge === "object"
 	) {
-		const extra = (optimistic as { merge: Record<string, unknown> })["merge"];
+		const extra = (optimistic as { merge: Record<string, unknown> }).merge;
 		const args: Record<string, unknown> = { type: entityType };
 		for (const field of inputFields) {
 			args[field] = { $input: field };
@@ -823,11 +823,16 @@ class LensServerImpl<
 				};
 			};
 
-			const result = resolver({
-				input: sub.input,
-				ctx: context,
+			// Merge Lens extensions (emit, onCleanup) into user context
+			const lensContext = {
+				...context,
 				emit,
 				onCleanup,
+			};
+
+			const result = resolver({
+				input: sub.input,
+				ctx: lensContext,
 			});
 
 			if (isAsyncIterable(result)) {
@@ -1042,11 +1047,16 @@ class LensServerImpl<
 				const emit = createEmit(() => {});
 				const onCleanup = () => () => {};
 
-				const result = resolver({
-					input: cleanInput as TInput,
-					ctx: context,
+				// Merge Lens extensions (emit, onCleanup) into user context
+				const lensContext = {
+					...context,
 					emit,
 					onCleanup,
+				};
+
+				const result = resolver({
+					input: cleanInput as TInput,
+					ctx: lensContext,
 				});
 
 				let data: TOutput;
@@ -1096,11 +1106,16 @@ class LensServerImpl<
 				const emit = createEmit(() => {});
 				const onCleanup = () => () => {};
 
-				const result = await resolver({
-					input: input as TInput,
-					ctx: context,
+				// Merge Lens extensions (emit, onCleanup) into user context
+				const lensContext = {
+					...context,
 					emit,
 					onCleanup,
+				};
+
+				const result = await resolver({
+					input: input as TInput,
+					ctx: lensContext,
 				});
 
 				// Emit to GraphStateManager
@@ -1300,7 +1315,7 @@ class LensServerImpl<
 
 		// Always include id
 		if ("id" in obj) {
-			result["id"] = obj["id"];
+			result.id = obj.id;
 		}
 
 		// Handle string array (simple field list)

package/src/state/graph-state-manager.test.ts

@@ -62,7 +62,7 @@ describe("GraphStateManager", () => {
 				entity: "Post",
 				id: "123",
 			});
-			expect(mockClient.messages[0].updates["title"]).toMatchObject({
+			expect(mockClient.messages[0].updates.title).toMatchObject({
 				strategy: "value",
 				data: "Hello",
 			});
@@ -179,7 +179,7 @@ describe("GraphStateManager", () => {
 
 			manager.emit("Post", "123", { title: "World" });
 
-			expect(mockClient.messages[0].updates["title"].strategy).toBe("value");
+			expect(mockClient.messages[0].updates.title.strategy).toBe("value");
 		});
 
 		it("uses delta strategy for long strings with small changes", () => {
@@ -191,7 +191,7 @@ describe("GraphStateManager", () => {
 			manager.emit("Post", "123", { content: `${longText} appended` });
 
 			// Should use delta for efficient transfer
-			const update = mockClient.messages[0].updates["content"];
+			const update = mockClient.messages[0].updates.content;
 			expect(["delta", "value"]).toContain(update.strategy);
 		});
 
@@ -206,7 +206,7 @@ describe("GraphStateManager", () => {
 				metadata: { views: 101, likes: 10, tags: ["a", "b"] },
 			});
 
-			const update = mockClient.messages[0].updates["metadata"];
+			const update = mockClient.messages[0].updates.metadata;
 			expect(["patch", "value"]).toContain(update.strategy);
 		});
 	});
@@ -258,12 +258,12 @@ describe("GraphStateManager", () => {
 
 			// client-1 got incremental update
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["title"].data).toBe("Updated");
+			expect(mockClient.messages[0].updates.title.data).toBe("Updated");
 
 			// client-2 got full current state
 			expect(client2.messages.length).toBe(1);
-			expect(client2.messages[0].updates["title"].data).toBe("Updated");
-			expect(client2.messages[0].updates["content"].data).toBe("World");
+			expect(client2.messages[0].updates.title.data).toBe("Updated");
+			expect(client2.messages[0].updates.content.data).toBe("World");
 		});
 	});
 
@@ -390,7 +390,7 @@ describe("GraphStateManager", () => {
 			manager.emitField("Post", "123", "title", { strategy: "value", data: "Hello World" });
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["title"]).toEqual({
+			expect(mockClient.messages[0].updates.title).toEqual({
 				strategy: "value",
 				data: "Hello World",
 			});
@@ -424,7 +424,7 @@ describe("GraphStateManager", () => {
 			});
 
 			const state = manager.getState("Post", "123");
-			expect(state?.["metadata"]).toEqual({ views: 101, likes: 10 });
+			expect(state?.metadata).toEqual({ views: 101, likes: 10 });
 		});
 
 		it("sends field update to subscribed clients only for subscribed fields", () => {
@@ -480,9 +480,9 @@ describe("GraphStateManager", () => {
 			]);
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["title"].data).toBe("Hello");
-			expect(mockClient.messages[0].updates["content"].data).toBe("World");
-			expect(mockClient.messages[0].updates["author"].data).toBe("Alice");
+			expect(mockClient.messages[0].updates.title.data).toBe("Hello");
+			expect(mockClient.messages[0].updates.content.data).toBe("World");
+			expect(mockClient.messages[0].updates.author.data).toBe("Alice");
 		});
 
 		it("applies batch updates to canonical state", () => {
@@ -712,7 +712,7 @@ describe("GraphStateManager", () => {
 			});
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["author"].data).toEqual({
+			expect(mockClient.messages[0].updates.author.data).toEqual({
 				id: "1",
 				name: "Alice",
 				profile: {
@@ -792,7 +792,7 @@ describe("GraphStateManager", () => {
 
 			// Should have 10 updates
 			expect(mockClient.messages.length).toBe(10);
-			expect(mockClient.messages[9].updates["counter"].data).toBe(9);
+			expect(mockClient.messages[9].updates.counter.data).toBe(9);
 		});
 
 		it("handles large number of subscribers to same entity", () => {
@@ -815,7 +815,7 @@ describe("GraphStateManager", () => {
 			// All clients should receive the update
 			for (const client of clients) {
 				expect(client.messages.length).toBe(1);
-				expect(client.messages[0].updates["title"].data).toBe("Broadcast");
+				expect(client.messages[0].updates.title.data).toBe("Broadcast");
 			}
 		});
 
@@ -842,14 +842,14 @@ describe("GraphStateManager", () => {
 			manager.emit("Post", "123", { tags: ["javascript", "typescript"] });
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["tags"].data).toEqual(["javascript", "typescript"]);
+			expect(mockClient.messages[0].updates.tags.data).toEqual(["javascript", "typescript"]);
 
 			// Update array
 			mockClient.messages = [];
 			manager.emit("Post", "123", { tags: ["javascript", "typescript", "react"] });
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["tags"].data).toEqual(["javascript", "typescript", "react"]);
+			expect(mockClient.messages[0].updates.tags.data).toEqual(["javascript", "typescript", "react"]);
 		});
 
 		it("handles boolean field values", () => {
@@ -859,14 +859,14 @@ describe("GraphStateManager", () => {
 			manager.emit("Post", "123", { published: true });
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["published"].data).toBe(true);
+			expect(mockClient.messages[0].updates.published.data).toBe(true);
 
 			// Toggle boolean
 			mockClient.messages = [];
 			manager.emit("Post", "123", { published: false });
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["published"].data).toBe(false);
+			expect(mockClient.messages[0].updates.published.data).toBe(false);
 		});
 
 		it("handles number field values including 0", () => {
@@ -876,14 +876,14 @@ describe("GraphStateManager", () => {
 			manager.emit("Post", "123", { likes: 0 });
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["likes"].data).toBe(0);
+			expect(mockClient.messages[0].updates.likes.data).toBe(0);
 
 			// Update to positive number
 			mockClient.messages = [];
 			manager.emit("Post", "123", { likes: 5 });
 
 			expect(mockClient.messages.length).toBe(1);
-			expect(mockClient.messages[0].updates["likes"].data).toBe(5);
+			expect(mockClient.messages[0].updates.likes.data).toBe(5);
 		});
 	});
 
@@ -909,7 +909,7 @@ describe("GraphStateManager", () => {
 				entity: "Users",
 				id: "list",
 			});
-			expect(mockClient.messages[0].updates["_items"].data).toEqual([
+			expect(mockClient.messages[0].updates._items.data).toEqual([
 				{ id: "1", name: "Alice" },
 				{ id: "2", name: "Bob" },
 			]);
@@ -1086,7 +1086,7 @@ describe("GraphStateManager", () => {
 
 			expect(mockClient.messages.length).toBe(2);
 			// Second message should be incremental diff (push operation)
-			const update = mockClient.messages[1].updates["_items"];
+			const update = mockClient.messages[1].updates._items;
 			expect(update.strategy).toBe("array");
 			expect(update.data).toEqual([{ op: "push", item: { id: "2", name: "Bob" } }]);
 		});