@sylphx/lens-server 1.0.4 → 1.3.0

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,11 +10,14 @@
 
 import {
 	type ContextValue,
+	type Emit,
+	type EmitCommand,
 	type EntityDef,
 	type EntityDefinition,
 	type EntityResolvers,
 	type EntityResolversDefinition,
 	type FieldType,
+	type InferRouterContext,
 	type MutationDef,
 	type QueryDef,
 	type RelationDef,
@@ -22,6 +25,7 @@ import {
 	type RouterDef,
 	type Update,
 	createContext,
+	createEmit,
 	createUpdate,
 	flattenRouter,
 	isBatchResolver,
@@ -69,20 +73,23 @@ export type OperationsMap = {
 };
 
 /** Server configuration */
-export interface LensServerConfig<TContext extends ContextValue = ContextValue> {
+export interface LensServerConfig<
+	TContext extends ContextValue = ContextValue,
+	TRouter extends RouterDef = RouterDef,
+> {
 	/** Entity definitions */
 	entities?: EntitiesMap;
 	/** Relation definitions */
 	relations?: RelationsArray;
-	/** Router definition (namespaced operations) */
-	router?: RouterDef;
+	/** Router definition (namespaced operations) - context type is inferred */
+	router?: TRouter;
 	/** Query definitions (flat, legacy) */
 	queries?: QueriesMap;
 	/** Mutation definitions (flat, legacy) */
 	mutations?: MutationsMap;
 	/** Entity resolvers */
 	resolvers?: EntityResolvers<EntityResolversDefinition>;
-	/** Context factory */
+	/** Context factory - must return the context type expected by the router */
 	context?: (req?: unknown) => TContext | Promise<TContext>;
 	/** Server version */
 	version?: string;
@@ -666,22 +673,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 +914,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 +968,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
@@ -1520,17 +1550,85 @@ export type InferApi<T extends LensServer> = T extends LensServerImpl<infer Q, i
 // Factory
 // =============================================================================
 
+/**
+ * Config helper type that infers context from router
+ */
+export type ServerConfigWithInferredContext<
+	TRouter extends RouterDef,
+	Q extends QueriesMap = QueriesMap,
+	M extends MutationsMap = MutationsMap,
+> = {
+	entities?: EntitiesMap;
+	relations?: RelationsArray;
+	router: TRouter;
+	queries?: Q;
+	mutations?: M;
+	resolvers?: EntityResolvers<EntityResolversDefinition>;
+	/** Context factory - type is inferred from router's procedures */
+	context?: (req?: unknown) => InferRouterContext<TRouter> | Promise<InferRouterContext<TRouter>>;
+	version?: string;
+};
+
+/**
+ * Config without router (legacy flat queries/mutations)
+ */
+export type ServerConfigLegacy<
+	TContext extends ContextValue = ContextValue,
+	Q extends QueriesMap = QueriesMap,
+	M extends MutationsMap = MutationsMap,
+> = {
+	entities?: EntitiesMap;
+	relations?: RelationsArray;
+	router?: undefined;
+	queries?: Q;
+	mutations?: M;
+	resolvers?: EntityResolvers<EntityResolversDefinition>;
+	context?: (req?: unknown) => TContext | Promise<TContext>;
+	version?: string;
+};
+
 /**
  * Create Lens server with Operations API + Optimization Layer
+ *
+ * When using a router with typed context (from initLens), the context
+ * function's return type is automatically enforced to match.
+ *
+ * @example
+ * ```typescript
+ * // Context type is inferred from router's procedures
+ * const server = createServer({
+ *   router: appRouter,  // RouterDef with MyContext
+ *   context: () => ({
+ *     db: prisma,
+ *     user: null,
+ *   }),  // Must match MyContext!
+ * })
+ * ```
  */
+export function createServer<
+	TRouter extends RouterDef,
+	Q extends QueriesMap = QueriesMap,
+	M extends MutationsMap = MutationsMap,
+>(
+	config: ServerConfigWithInferredContext<TRouter, Q, M>,
+): LensServer & { _types: { queries: Q; mutations: M; context: InferRouterContext<TRouter> } };
+
+export function createServer<
+	TContext extends ContextValue = ContextValue,
+	Q extends QueriesMap = QueriesMap,
+	M extends MutationsMap = MutationsMap,
+>(
+	config: ServerConfigLegacy<TContext, Q, M>,
+): LensServer & { _types: { queries: Q; mutations: M; context: TContext } };
+
 export function createServer<
 	TContext extends ContextValue = ContextValue,
 	Q extends QueriesMap = QueriesMap,
 	M extends MutationsMap = MutationsMap,
 >(
 	config: LensServerConfig<TContext> & { queries?: Q; mutations?: M },
-): LensServer & { _types: { queries: Q; mutations: M } } {
-	const server = new LensServerImpl(config) as LensServerImpl<Q, M>;
+): LensServer & { _types: { queries: Q; mutations: M; context: TContext } } {
+	const server = new LensServerImpl(config) as LensServerImpl<Q, M, TContext>;
 	// Attach type marker for inference (stripped at runtime)
-	return server as unknown as LensServer & { _types: { queries: Q; mutations: M } };
+	return server as unknown as LensServer & { _types: { queries: Q; mutations: M; context: TContext } };
 }

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);
+		});
+	});
 });