@sylphx/lens-server 1.0.3 → 1.2.0

package/src/e2e/server.test.ts

@@ -306,14 +306,14 @@ describe("E2E - Subscriptions", () => {
 		expect(received[0]).toMatchObject({ name: "Alice" });
 	});
 
-	it("subscribe receives updates via ctx.emit", async () => {
+	it("subscribe receives updates via emit", async () => {
 		let emitFn: ((data: unknown) => void) | null = null;
 
 		const watchUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, ctx }) => {
-				emitFn = ctx.emit;
+			.resolve(({ input, emit }) => {
+				emitFn = emit;
 				return mockUsers.find((u) => u.id === input.id) ?? null;
 			});
 
@@ -355,8 +355,8 @@ describe("E2E - Subscriptions", () => {
 		const watchUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, ctx }) => {
-				emitFn = ctx.emit;
+			.resolve(({ input, emit }) => {
+				emitFn = emit;
 				return mockUsers.find((u) => u.id === input.id) ?? null;
 			});
 
@@ -447,7 +447,7 @@ describe("E2E - Server API", () => {
 });
 
 // =============================================================================
-// Test: Cleanup (ctx.onCleanup)
+// Test: Cleanup (onCleanup)
 // =============================================================================
 
 describe("E2E - Cleanup", () => {
@@ -457,8 +457,8 @@ describe("E2E - Cleanup", () => {
 		const watchUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, ctx }) => {
-				ctx.onCleanup(() => {
+			.resolve(({ input, onCleanup }) => {
+				onCleanup(() => {
 					cleanedUp = true;
 				});
 				return mockUsers.find((u) => u.id === input.id) ?? null;
@@ -497,8 +497,8 @@ describe("E2E - GraphStateManager", () => {
 		const getUser = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, ctx }) => {
-				emitFn = ctx.emit;
+			.resolve(({ input, emit }) => {
+				emitFn = emit;
 				return mockUsers.find((u) => u.id === input.id) ?? null;
 			});
 

package/src/server/create.test.ts

@@ -644,8 +644,8 @@ describe("Minimum Transfer", () => {
 
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ ctx }) => {
-				emitFn = ctx.emit;
+			.resolve(({ emit }) => {
+				emitFn = emit;
 				return { id: "1", name: "Alice", email: "alice@example.com" };
 			});
 
@@ -681,13 +681,13 @@ describe("Minimum Transfer", () => {
 		}
 	});
 
-	it("sends updates via ctx.emit", async () => {
+	it("sends updates via emit", async () => {
 		let emitFn: ((data: unknown) => void) | null = null;
 
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ ctx }) => {
-				emitFn = ctx.emit;
+			.resolve(({ emit }) => {
+				emitFn = emit;
 				return { id: "1", name: "Alice", email: "alice@example.com" };
 			});
 
@@ -723,17 +723,17 @@ describe("Minimum Transfer", () => {
 });
 
 // =============================================================================
-// Test: ctx.onCleanup
+// Test: onCleanup
 // =============================================================================
 
-describe("ctx.onCleanup", () => {
+describe("onCleanup", () => {
 	it("calls cleanup function on unsubscribe", async () => {
 		let cleanedUp = false;
 
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ ctx }) => {
-				ctx.onCleanup(() => {
+			.resolve(({ onCleanup }) => {
+				onCleanup(() => {
 					cleanedUp = true;
 				});
 				return mockUsers[0];
@@ -772,8 +772,8 @@ describe("ctx.onCleanup", () => {
 
 		const liveQuery = query()
 			.returns(User)
-			.resolve(({ ctx }) => {
-				ctx.onCleanup(() => {
+			.resolve(({ onCleanup }) => {
+				onCleanup(() => {
 					cleanedUp = true;
 				});
 				return mockUsers[0];

package/src/server/create.ts

@@ -10,6 +10,8 @@
 
 import {
 	type ContextValue,
+	type Emit,
+	type EmitCommand,
 	type EntityDef,
 	type EntityDefinition,
 	type EntityResolvers,
@@ -22,6 +24,7 @@ import {
 	type RouterDef,
 	type Update,
 	createContext,
+	createEmit,
 	createUpdate,
 	flattenRouter,
 	isBatchResolver,
@@ -666,22 +669,37 @@ class LensServerImpl<
 				throw new Error(`Query ${sub.operation} has no resolver`);
 			}
 
-			// Add emit and onCleanup to context for subscriptions
-			const contextWithHelpers = {
-				...context,
-				emit: emitData,
-				onCleanup: (fn: () => void) => {
-					sub.cleanups.push(fn);
-					return () => {
-						const idx = sub.cleanups.indexOf(fn);
-						if (idx >= 0) sub.cleanups.splice(idx, 1);
-					};
-				},
+			// Create emit API for this subscription
+			const emit = createEmit((command: EmitCommand) => {
+				// Route emit commands to appropriate handler
+				const entityName = this.getEntityNameFromOutput(queryDef._output);
+				if (entityName) {
+					// For entity-typed outputs, use GraphStateManager
+					const entities = this.extractEntities(entityName, command.type === "full" ? command.data : {});
+					for (const { entity, id } of entities) {
+						this.stateManager.processCommand(entity, id, command);
+					}
+				}
+				// Also emit the raw data for operation-level updates
+				if (command.type === "full") {
+					emitData(command.data);
+				}
+			});
+
+			// Create onCleanup function
+			const onCleanup = (fn: () => void) => {
+				sub.cleanups.push(fn);
+				return () => {
+					const idx = sub.cleanups.indexOf(fn);
+					if (idx >= 0) sub.cleanups.splice(idx, 1);
+				};
 			};
 
 			const result = resolver({
 				input: sub.input,
-				ctx: contextWithHelpers,
+				ctx: context,
+				emit,
+				onCleanup,
 			});
 
 			if (isAsyncIterable(result)) {
@@ -892,14 +910,16 @@ class LensServerImpl<
 					throw new Error(`Query ${name} has no resolver`);
 				}
 
-				const resolverCtx = {
-					input: cleanInput as TInput,
-					ctx: context, // Pass context directly to resolver (tRPC style)
-					emit: () => {},
-					onCleanup: () => () => {},
-				};
+				// Create no-op emit for one-shot queries (emit is only meaningful in subscriptions)
+				const emit = createEmit(() => {});
+				const onCleanup = () => () => {};
 
-				const result = resolver(resolverCtx);
+				const result = resolver({
+					input: cleanInput as TInput,
+					ctx: context,
+					emit,
+					onCleanup,
+				});
 
 				let data: TOutput;
 				if (isAsyncIterable(result)) {
@@ -944,9 +964,15 @@ class LensServerImpl<
 					throw new Error(`Mutation ${name} has no resolver`);
 				}
 
+				// Create no-op emit for mutations (emit is primarily for subscriptions)
+				const emit = createEmit(() => {});
+				const onCleanup = () => () => {};
+
 				const result = await resolver({
 					input: input as TInput,
-					ctx: context, // Pass context directly to resolver (tRPC style)
+					ctx: context,
+					emit,
+					onCleanup,
 				});
 
 				// Emit to GraphStateManager

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

@@ -331,4 +331,219 @@ describe("GraphStateManager", () => {
 			expect(stats.totalSubscriptions).toBe(3);
 		});
 	});
+
+	describe("array operations", () => {
+		interface User {
+			id: string;
+			name: string;
+		}
+
+		it("emits array data", () => {
+			manager.subscribe("client-1", "Users", "list", "*");
+			mockClient.messages = [];
+
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+
+			expect(mockClient.messages.length).toBe(1);
+			expect(mockClient.messages[0]).toMatchObject({
+				type: "update",
+				entity: "Users",
+				id: "list",
+			});
+			expect(mockClient.messages[0].updates._items.data).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+		});
+
+		it("gets array state", () => {
+			manager.emitArray("Users", "list", [{ id: "1", name: "Alice" }]);
+
+			expect(manager.getArrayState("Users", "list")).toEqual([{ id: "1", name: "Alice" }]);
+		});
+
+		it("applies push operation", () => {
+			manager.emitArray("Users", "list", [{ id: "1", name: "Alice" }]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "push",
+				item: { id: "2", name: "Bob" },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+		});
+
+		it("applies unshift operation", () => {
+			manager.emitArray("Users", "list", [{ id: "1", name: "Alice" }]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "unshift",
+				item: { id: "0", name: "Zero" },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "0", name: "Zero" },
+				{ id: "1", name: "Alice" },
+			]);
+		});
+
+		it("applies insert operation", () => {
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "3", name: "Charlie" },
+			]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "insert",
+				index: 1,
+				item: { id: "2", name: "Bob" },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+				{ id: "3", name: "Charlie" },
+			]);
+		});
+
+		it("applies remove operation", () => {
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+			manager.emitArrayOperation("Users", "list", { op: "remove", index: 0 });
+
+			expect(manager.getArrayState("Users", "list")).toEqual([{ id: "2", name: "Bob" }]);
+		});
+
+		it("applies removeById operation", () => {
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+			manager.emitArrayOperation("Users", "list", { op: "removeById", id: "1" });
+
+			expect(manager.getArrayState("Users", "list")).toEqual([{ id: "2", name: "Bob" }]);
+		});
+
+		it("handles removeById for non-existent id", () => {
+			manager.emitArray("Users", "list", [{ id: "1", name: "Alice" }]);
+			manager.emitArrayOperation("Users", "list", { op: "removeById", id: "999" });
+
+			expect(manager.getArrayState("Users", "list")).toEqual([{ id: "1", name: "Alice" }]);
+		});
+
+		it("applies update operation", () => {
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "update",
+				index: 1,
+				item: { id: "2", name: "Robert" },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Robert" },
+			]);
+		});
+
+		it("applies updateById operation", () => {
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "updateById",
+				id: "2",
+				item: { id: "2", name: "Robert" },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Robert" },
+			]);
+		});
+
+		it("applies merge operation", () => {
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "merge",
+				index: 0,
+				partial: { name: "Alicia" },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "1", name: "Alicia" },
+				{ id: "2", name: "Bob" },
+			]);
+		});
+
+		it("applies mergeById operation", () => {
+			manager.emitArray("Users", "list", [
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "mergeById",
+				id: "2",
+				partial: { name: "Bobby" },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bobby" },
+			]);
+		});
+
+		it("processCommand handles array operations", () => {
+			manager.emitArray("Users", "list", [{ id: "1", name: "Alice" }]);
+
+			manager.processCommand("Users", "list", {
+				type: "array",
+				operation: { op: "push", item: { id: "2", name: "Bob" } },
+			});
+
+			expect(manager.getArrayState("Users", "list")).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+		});
+
+		it("sends array updates to subscribed clients", () => {
+			manager.subscribe("client-1", "Users", "list", "*");
+			mockClient.messages = [];
+
+			manager.emitArray("Users", "list", [{ id: "1", name: "Alice" }]);
+			manager.emitArrayOperation("Users", "list", {
+				op: "push",
+				item: { id: "2", name: "Bob" },
+			});
+
+			expect(mockClient.messages.length).toBe(2);
+			expect(mockClient.messages[1].updates._items.data).toEqual([
+				{ id: "1", name: "Alice" },
+				{ id: "2", name: "Bob" },
+			]);
+		});
+
+		it("does not send update if array unchanged", () => {
+			manager.subscribe("client-1", "Users", "list", "*");
+			manager.emitArray("Users", "list", [{ id: "1", name: "Alice" }]);
+			mockClient.messages = [];
+
+			// Remove by non-existent id (no change)
+			manager.emitArrayOperation("Users", "list", { op: "removeById", id: "999" });
+
+			expect(mockClient.messages.length).toBe(0);
+		});
+	});
 });