@sylphx/lens-server 3.0.1 → 4.0.0

package/src/server/create.ts

@@ -23,22 +23,22 @@ import {
 	createResolverFromEntity,
 	type Emit,
 	type EmitCommand,
-	type EntityDef,
 	flattenRouter,
 	hashValue,
-	hasInlineResolvers,
 	type InferRouterContext,
-	isEntityDef,
 	isLiveQueryDef,
 	isModelDef,
 	isMutationDef,
 	isQueryDef,
+	isSubscriptionDef,
 	type LiveQueryDef,
 	type Message,
+	type ModelDef,
 	mergeModelCollections,
 	type Observable,
 	type ResolverDef,
 	type RouterDef,
+	type SubscriptionDef,
 	toOps,
 	valuesEqual,
 } from "@sylphx/lens-core";
@@ -63,6 +63,7 @@ import type {
 	ServerConfigLegacy,
 	ServerConfigWithInferredContext,
 	ServerMetadata,
+	SubscriptionsMap,
 } from "./types.js";
 
 // Re-export types
@@ -87,6 +88,7 @@ export type {
 	ServerConfigLegacy,
 	ServerConfigWithInferredContext,
 	ServerMetadata,
+	SubscriptionsMap,
 	WebSocketLike,
 } from "./types.js";
 
@@ -110,25 +112,31 @@ type ResolverMap = Map<string, ResolverDef<any, any, any>>;
 class LensServerImpl<
 	Q extends QueriesMap = QueriesMap,
 	M extends MutationsMap = MutationsMap,
+	S extends SubscriptionsMap = SubscriptionsMap,
 	TContext extends ContextValue = ContextValue,
 > implements LensServer
 {
 	private queries: Q;
 	private mutations: M;
+	private subscriptions: S;
 	private entities: EntitiesMap;
 	private resolverMap?: ResolverMap | undefined;
 	private contextFactory: (req?: unknown) => TContext | Promise<TContext>;
 	private version: string;
 	private logger: LensLogger;
 	private ctx = createContext<TContext>();
-	private loaders = new Map<string, DataLoader<unknown, unknown>>();
 	private pluginManager: PluginManager;
+	/** Cache for computed type names - O(n×m) entity matching is expensive */
+	private typeNameCache = new WeakMap<object, string | undefined>();
 
-	constructor(config: LensServerConfig<TContext> & { queries?: Q; mutations?: M }) {
+	constructor(
+		config: LensServerConfig<TContext> & { queries?: Q; mutations?: M; subscriptions?: S },
+	) {
 		const queries: QueriesMap = { ...(config.queries ?? {}) };
 		const mutations: MutationsMap = { ...(config.mutations ?? {}) };
+		const subscriptions: SubscriptionsMap = { ...(config.subscriptions ?? {}) };
 
-		// Flatten router into queries/mutations
+		// Flatten router into queries/mutations/subscriptions
 		if (config.router) {
 			const flattened = flattenRouter(config.router);
 			for (const [path, procedure] of flattened) {
@@ -136,12 +144,15 @@ class LensServerImpl<
 					queries[path] = procedure;
 				} else if (isMutationDef(procedure)) {
 					mutations[path] = procedure;
+				} else if (isSubscriptionDef(procedure)) {
+					subscriptions[path] = procedure;
 				}
 			}
 		}
 
 		this.queries = queries as Q;
 		this.mutations = mutations as M;
+		this.subscriptions = subscriptions as S;
 
 		// Build entities map (priority: explicit config > router > resolvers)
 		// Auto-track models from router return types (new behavior)
@@ -163,19 +174,17 @@ class LensServerImpl<
 			}
 		}
 
-		// Convert Map to Record for entities (supports both EntityDef and ModelDef)
+		// Convert Map to Record for entities
 		const entities: EntitiesMap = {};
 		for (const [name, model] of mergedModels) {
-			// Both ModelDef and EntityDef work as EntitiesMap values
-			if (isEntityDef(model) || isModelDef(model)) {
-				entities[name] = model as EntityDef<string, any>;
+			if (isModelDef(model)) {
+				entities[name] = model as ModelDef<string, any>;
 			}
 		}
 		this.entities = entities;
 
-		// Build resolver map: explicit resolvers + auto-converted from entities with inline resolvers
-		// Unified Entity Definition (ADR-001): entities can have inline .resolve()/.subscribe() methods
-		// These are automatically converted to resolvers, no need to call createResolverFromEntity() manually
+		// Build resolver map: explicit resolvers + auto-generated exposed-only resolvers
+		// Models without explicit resolvers get auto-generated exposed-only resolvers
 		this.resolverMap = this.buildResolverMap(config.resolvers, entities);
 		this.contextFactory = config.context ?? (() => ({}) as TContext);
 		this.version = config.version ?? "1.0.0";
@@ -208,6 +217,11 @@ class LensServerImpl<
 				(def as { _name?: string })._name = name;
 			}
 		}
+		for (const [name, def] of Object.entries(this.subscriptions)) {
+			if (def && typeof def === "object") {
+				(def as { _name?: string })._name = name;
+			}
+		}
 	}
 
 	private validateDefinitions(): void {
@@ -221,15 +235,20 @@ class LensServerImpl<
 				throw new Error(`Invalid mutation definition: ${name}`);
 			}
 		}
+		for (const [name, def] of Object.entries(this.subscriptions)) {
+			if (!isSubscriptionDef(def)) {
+				throw new Error(`Invalid subscription definition: ${name}`);
+			}
+		}
 	}
 
 	/**
-	 * Build resolver map from explicit resolvers and entities with inline resolvers.
+	 * Build resolver map from explicit resolvers.
 	 *
-	 * Unified Entity Definition (ADR-001): Entities can have inline .resolve()/.subscribe() methods.
-	 * These are automatically converted to resolvers - no manual createResolverFromEntity() needed.
+	 * Models without explicit resolvers get auto-generated exposed-only resolvers.
+	 * Use standalone resolver(Model, ...) for custom field resolution.
 	 *
-	 * Priority: explicit resolvers > auto-converted from entities
+	 * Priority: explicit resolvers > auto-generated exposed-only resolvers
 	 */
 	private buildResolverMap(
 		explicitResolvers: import("@sylphx/lens-core").Resolvers | undefined,
@@ -247,17 +266,14 @@ class LensServerImpl<
 			}
 		}
 
-		// 2. Auto-convert entities/models with inline resolvers (if not already in map)
+		// 2. Auto-create exposed-only resolvers for models without explicit resolvers
 		for (const [name, entity] of Object.entries(entities)) {
-			// Support both EntityDef and ModelDef
-			if (!isEntityDef(entity) && !isModelDef(entity)) continue;
+			if (!isModelDef(entity)) continue;
 			if (resolverMap.has(name)) continue; // Explicit resolver takes priority
 
-			// Check if entity/model has inline resolvers
-			if (hasInlineResolvers(entity)) {
-				const resolver = createResolverFromEntity(entity);
-				resolverMap.set(name, resolver);
-			}
+			// Create exposed-only resolver for this model
+			const resolver = createResolverFromEntity(entity);
+			resolverMap.set(name, resolver);
 		}
 
 		return resolverMap.size > 0 ? resolverMap : undefined;
@@ -315,8 +331,9 @@ class LensServerImpl<
 		// Check if operation exists
 		const isQuery = !!this.queries[path];
 		const isMutation = !!this.mutations[path];
+		const isSubscription = !!this.subscriptions[path];
 
-		if (!isQuery && !isMutation) {
+		if (!isQuery && !isMutation && !isSubscription) {
 			return {
 				subscribe: (observer) => {
 					observer.next?.({
@@ -330,9 +347,132 @@ class LensServerImpl<
 			};
 		}
 
+		// Subscriptions are handled differently - they only emit events (no initial data)
+		if (isSubscription) {
+			return this.executeSubscription(path, input);
+		}
+
 		return this.executeAsObservable(path, input, isQuery);
 	}
 
+	/**
+	 * Execute subscription and return Observable.
+	 * Subscriptions only emit events - no initial data fetch.
+	 */
+	private executeSubscription(path: string, input: unknown): Observable<LensResult> {
+		return {
+			subscribe: (observer) => {
+				let cancelled = false;
+				const cleanups: (() => void)[] = [];
+
+				(async () => {
+					try {
+						const def = this.subscriptions[path] as SubscriptionDef<unknown, unknown, TContext>;
+						if (!def) {
+							observer.next?.({
+								$: "error",
+								error: `Subscription not found: ${path}`,
+								code: "NOT_FOUND",
+							} as Message);
+							observer.complete?.();
+							return;
+						}
+
+						// Validate input
+						if (def._input && input !== undefined) {
+							if (def._input.safeParse) {
+								const result = def._input.safeParse(input);
+								if (!result.success) {
+									observer.next?.({
+										$: "error",
+										error: `Invalid input: ${JSON.stringify(result.error)}`,
+										code: "VALIDATION_ERROR",
+									} as Message);
+									observer.complete?.();
+									return;
+								}
+							} else {
+								try {
+									def._input.parse(input);
+								} catch (e) {
+									observer.next?.({
+										$: "error",
+										error: `Invalid input: ${e instanceof Error ? e.message : String(e)}`,
+										code: "VALIDATION_ERROR",
+									} as Message);
+									observer.complete?.();
+									return;
+								}
+							}
+						}
+
+						const context = await this.contextFactory();
+						const subscriber = def._subscriber;
+
+						if (!subscriber) {
+							observer.next?.({
+								$: "error",
+								error: `Subscription ${path} has no subscriber`,
+								code: "NO_SUBSCRIBER",
+							} as Message);
+							observer.complete?.();
+							return;
+						}
+
+						// Get the publisher function
+						const publisher = subscriber({ input, ctx: context });
+
+						// Call publisher with emit/onCleanup callbacks
+						if (publisher) {
+							// Create a proper Emit instance for subscriptions
+							const emit = createEmit((command: EmitCommand) => {
+								if (cancelled) return;
+								// For subscriptions, emit full value as snapshot
+								if (command.type === "full") {
+									observer.next?.({ $: "snapshot", data: command.data } as Message);
+								}
+							}, "scalar");
+
+							publisher({
+								emit,
+								onCleanup: (fn) => {
+									cleanups.push(fn);
+									return fn;
+								},
+							});
+						}
+
+						// Note: Subscriptions stay open until unsubscribed
+						// They do NOT call observer.complete() automatically
+					} catch (error) {
+						// Call cleanup functions on error path - important for resource cleanup
+						for (const fn of cleanups) {
+							try {
+								fn();
+							} catch {
+								// Ignore cleanup errors
+							}
+						}
+						if (!cancelled) {
+							const errMsg = error instanceof Error ? error.message : String(error);
+							observer.next?.({ $: "error", error: errMsg, code: "INTERNAL_ERROR" } as Message);
+							observer.complete?.();
+						}
+					}
+				})();
+
+				return {
+					unsubscribe: () => {
+						cancelled = true;
+						for (const fn of cleanups) {
+							fn();
+						}
+					},
+				};
+			},
+		};
+	}
+
 	/**
 	 * Execute operation and return Observable.
 	 * Observable allows streaming for AsyncIterable resolvers and emit-based updates.
@@ -391,15 +531,29 @@ class LensServerImpl<
 
 						// Validate input
 						if (def._input && cleanInput !== undefined) {
-							const result = def._input.safeParse(cleanInput);
-							if (!result.success) {
-								observer.next?.({
-									$: "error",
-									error: `Invalid input: ${JSON.stringify(result.error)}`,
-									code: "VALIDATION_ERROR",
-								} as Message);
-								observer.complete?.();
-								return;
+							if (def._input.safeParse) {
+								const result = def._input.safeParse(cleanInput);
+								if (!result.success) {
+									observer.next?.({
+										$: "error",
+										error: `Invalid input: ${JSON.stringify(result.error)}`,
+										code: "VALIDATION_ERROR",
+									} as Message);
+									observer.complete?.();
+									return;
+								}
+							} else {
+								try {
+									def._input.parse(cleanInput);
+								} catch (e) {
+									observer.next?.({
+										$: "error",
+										error: `Invalid input: ${e instanceof Error ? e.message : String(e)}`,
+										code: "VALIDATION_ERROR",
+									} as Message);
+									observer.complete?.();
+									return;
+								}
 							}
 						}
 
@@ -448,24 +602,47 @@ class LensServerImpl<
 								: undefined;
 
 							const lensContext = { ...context, emit, onCleanup };
-							const result = resolver({ args: cleanInput, input: cleanInput, ctx: lensContext });
+							const result = resolver({ args: cleanInput, ctx: lensContext } as any);
 
 							if (isAsyncIterable(result)) {
 								// Streaming: emit each yielded value
-								for await (const value of result) {
-									if (cancelled) break;
-									const processed = await this.processQueryResult(
-										path,
-										value,
-										select,
-										context,
-										onCleanup,
-										createFieldEmit,
-									);
-									emitIfChanged(processed);
-								}
-								if (!cancelled) {
-									observer.complete?.();
+								try {
+									for await (const value of result) {
+										if (cancelled) break;
+										const processed = await this.processQueryResult(
+											path,
+											value,
+											select,
+											context,
+											onCleanup,
+											createFieldEmit,
+										);
+										emitIfChanged(processed);
+									}
+									if (!cancelled) {
+										observer.complete?.();
+									}
+								} catch (iterError) {
+									// Handle errors from async iterator
+									// Call cleanup functions before reporting error
+									for (const fn of cleanups) {
+										try {
+											fn();
+										} catch {
+											// Ignore cleanup errors
+										}
+									}
+									if (!cancelled) {
+										const errMsg =
+											iterError instanceof Error ? iterError.message : String(iterError);
+										observer.next?.({
+											$: "error",
+											error: errMsg,
+											code: "STREAM_ERROR",
+										} as Message);
+										observer.complete?.();
+									}
+									return; // Don't continue to outer try block
 								}
 							} else {
 								// One-shot: emit single value
@@ -490,8 +667,7 @@ class LensServerImpl<
 										try {
 											// Get publisher function from subscriber
 											const publisher = liveQuery._subscriber({
-												args: cleanInput as never, // Preferred parameter name
-												input: cleanInput as never, // Deprecated alias for backwards compatibility
+												args: cleanInput as never,
 												ctx: context as TContext,
 											});
 											// Call publisher with emit/onCleanup callbacks
@@ -511,22 +687,38 @@ class LensServerImpl<
 									}
 								}
 
-								// Mutations complete immediately - they're truly one-shot
-								// Queries stay open for potential emit calls from field resolvers
-								if (!isQuery && !cancelled) {
-									observer.complete?.();
+								// Determine if query should remain open for live updates
+								const hasLiveSubscriptions = cleanups.length > 0;
+								const isLiveQuery = isQuery && isLiveQueryDef(def) && def._subscriber;
+
+								// Complete Observable:
+								// - Mutations: complete immediately (one-shot)
+								// - Queries without live fields/subscriptions: complete after initial data
+								// - Queries with live fields or LiveQueryDef with subscriber: stay open
+								if (!cancelled) {
+									if (!isQuery || (!hasLiveSubscriptions && !isLiveQuery)) {
+										observer.complete?.();
+									}
 								}
 							}
 						});
 					} catch (error) {
+						// Call cleanup functions on error path - important for resource cleanup
+						for (const fn of cleanups) {
+							try {
+								fn();
+							} catch {
+								// Ignore cleanup errors
+							}
+						}
 						if (!cancelled) {
 							const errMsg = error instanceof Error ? error.message : String(error);
 							observer.next?.({ $: "error", error: errMsg, code: "INTERNAL_ERROR" } as Message);
 							observer.complete?.();
 						}
-					} finally {
-						this.clearLoaders();
 					}
+					// Note: No need to clear loaders - they are now request-scoped
+					// (created fresh in processQueryResult for each request)
 				})();
 
 				return {
@@ -633,6 +825,9 @@ class LensServerImpl<
 		// Extract nested inputs from selection for field resolver args
 		const nestedInputs = select ? extractNestedInputs(select) : undefined;
 
+		// Create request-scoped loaders to avoid context leak across concurrent requests
+		const requestLoaders = new Map<string, DataLoader<unknown, unknown>>();
+
 		const processed = await this.resolveEntityFields(
 			data,
 			nestedInputs,
@@ -641,6 +836,7 @@ class LensServerImpl<
 			onCleanup,
 			createFieldEmit,
 			new Set(), // Cycle detection for circular entity references (type:id)
+			requestLoaders, // Request-scoped DataLoaders
 		);
 		if (select) {
 			return applySelection(processed, select) as T;
@@ -659,6 +855,7 @@ class LensServerImpl<
 	 * @param onCleanup - Cleanup registration for live query subscriptions
 	 * @param createFieldEmit - Factory for creating field-specific emit handlers
 	 * @param visited - Set of "type:id" keys to track visited entities and prevent circular reference infinite loops
+	 * @param loaders - Request-scoped DataLoader map to avoid context leak across concurrent requests
 	 */
 	private async resolveEntityFields<T>(
 		data: T,
@@ -668,6 +865,7 @@ class LensServerImpl<
 		onCleanup?: (fn: () => void) => void,
 		createFieldEmit?: (fieldPath: string, resolvedValue?: unknown) => Emit<unknown> | undefined,
 		visited: Set<string> = new Set(),
+		loaders: Map<string, DataLoader<unknown, unknown>> = new Map(),
 	): Promise<T> {
 		if (!data || !this.resolverMap) return data;
 
@@ -682,6 +880,7 @@ class LensServerImpl<
 						onCleanup,
 						createFieldEmit,
 						visited,
+						loaders,
 					),
 				),
 			) as Promise<T>;
@@ -722,21 +921,6 @@ class LensServerImpl<
 			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,
-					nestedInputs,
-					context,
-					currentPath,
-					onCleanup,
-					createFieldEmit,
-					visited,
-				);
-				continue;
-			}
-
 			// Resolve the field based on mode
 			// ADR-002: Two-Phase Field Resolution
 			const fieldMode = resolverDef.getFieldMode(field);
@@ -758,6 +942,7 @@ class LensServerImpl<
 							resolverDef,
 							field,
 							context ?? ({} as TContext),
+							loaders,
 						);
 						result[field] = await loader.load(obj);
 					}
@@ -778,39 +963,20 @@ class LensServerImpl<
 									},
 								});
 							}
-						} catch {
-							// Subscription errors are handled via emit, ignore here
-						}
-					}
-				} catch {
-					result[field] = null;
-				}
-			} else if (fieldMode === "subscribe") {
-				// SUBSCRIBE MODE (legacy): Call resolver with ctx.emit/ctx.onCleanup
-				// Legacy mode - resolver handles both initial value and updates via ctx.emit
-				try {
-					result[field] = null;
-					if (createFieldEmit && onCleanup) {
-						try {
-							const fieldEmit = createFieldEmit(currentPath);
-							if (fieldEmit) {
-								// Build legacy ctx with emit/onCleanup
-								const legacyCtx = {
-									...(context ?? {}),
-									emit: fieldEmit,
-									onCleanup: (fn: () => void) => {
-										onCleanup(fn);
-										return fn;
-									},
-								};
-								// Call legacy subscription method
-								resolverDef.subscribeFieldLegacy(field, obj, args, legacyCtx);
-							}
-						} catch {
-							// Subscription errors are handled via emit, ignore here
+						} catch (subscribeError) {
+							// Log subscription setup errors for debugging
+							this.logger.error?.(
+								`Field subscription error at ${currentPath}:`,
+								subscribeError instanceof Error ? subscribeError.message : String(subscribeError),
+							);
 						}
 					}
-				} catch {
+				} catch (resolveError) {
+					// Log live field resolution errors
+					this.logger.error?.(
+						`Live field resolution error at ${currentPath}:`,
+						resolveError instanceof Error ? resolveError.message : String(resolveError),
+					);
 					result[field] = null;
 				}
 			} else {
@@ -827,10 +993,16 @@ class LensServerImpl<
 							resolverDef,
 							field,
 							context ?? ({} as TContext),
+							loaders,
 						);
 						result[field] = await loader.load(obj);
 					}
-				} catch {
+				} catch (resolveError) {
+					// Log field resolution errors
+					this.logger.error?.(
+						`Field resolution error at ${currentPath}:`,
+						resolveError instanceof Error ? resolveError.message : String(resolveError),
+					);
 					result[field] = null;
 				}
 			}
@@ -844,6 +1016,7 @@ class LensServerImpl<
 				onCleanup,
 				createFieldEmit,
 				visited,
+				loaders,
 			);
 		}
 
@@ -855,20 +1028,27 @@ class LensServerImpl<
 	 *
 	 * Matching priority:
 	 * 1. Explicit __typename or _type property
-	 * 2. Best matching entity (highest field overlap score)
+	 * 2. Cached result from previous lookup
+	 * 3. Best matching entity (highest field overlap score)
 	 *
 	 * Requires at least 50% field match to avoid false positives.
+	 * Results are cached via WeakMap for O(1) repeated lookups.
 	 */
 	private getTypeName(obj: Record<string, unknown>): string | undefined {
-		// Priority 1: Explicit type marker
+		// Priority 1: Explicit type marker (fast path, no caching needed)
 		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
+		// Priority 2: Check cache for previously computed result
+		if (this.typeNameCache.has(obj)) {
+			return this.typeNameCache.get(obj);
+		}
+
+		// Priority 3: Find best matching entity by field overlap (O(n×m))
 		let bestMatch: { name: string; score: number } | undefined;
 
 		for (const [name, def] of Object.entries(this.entities)) {
-			if (!isEntityDef(def)) continue;
+			if (!isModelDef(def)) continue;
 
 			const score = this.getEntityMatchScore(obj, def);
 			// Require at least 50% field match to avoid false positives
@@ -877,7 +1057,10 @@ class LensServerImpl<
 			}
 		}
 
-		return bestMatch?.name;
+		const result = bestMatch?.name;
+		// Cache result (even undefined) to avoid repeated expensive lookups
+		this.typeNameCache.set(obj, result);
+		return result;
 	}
 
 	/**
@@ -887,7 +1070,7 @@ class LensServerImpl<
 	 */
 	private getEntityMatchScore(
 		obj: Record<string, unknown>,
-		entityDef: EntityDef<string, any>,
+		entityDef: ModelDef<string, any>,
 	): number {
 		const fieldNames = Object.keys(entityDef.fields);
 		if (fieldNames.length === 0) return 0;
@@ -901,11 +1084,12 @@ class LensServerImpl<
 		resolverDef: ResolverDef<any, any, any>,
 		fieldName: string,
 		context: TContext,
+		loaders: Map<string, DataLoader<unknown, unknown>>,
 	): DataLoader<unknown, unknown> {
-		let loader = this.loaders.get(loaderKey);
+		let loader = loaders.get(loaderKey);
 		if (!loader) {
-			// Capture context at loader creation time
-			// This ensures the batch function has access to request context
+			// Create loader with current request's context
+			// Using request-scoped loaders map ensures context isolation between concurrent requests
 			loader = new DataLoader(async (parents: unknown[]) => {
 				const results: unknown[] = [];
 				for (const parent of parents) {
@@ -923,15 +1107,11 @@ class LensServerImpl<
 				}
 				return results;
 			});
-			this.loaders.set(loaderKey, loader);
+			loaders.set(loaderKey, loader);
 		}
 		return loader;
 	}
 
-	private clearLoaders(): void {
-		this.loaders.clear();
-	}
-
 	// =========================================================================
 	// Operations Map
 	// =========================================================================
@@ -971,16 +1151,26 @@ class LensServerImpl<
 		};
 
 		for (const [name, def] of Object.entries(this.queries)) {
-			// Auto-detect subscription: if resolver is AsyncGeneratorFunction → subscription
-			const isSubscription =
+			// Auto-detect live query types:
+			// 1. AsyncGenerator-based: resolver returns async generator
+			// 2. Publisher-based: LiveQueryDef with _subscriber (ADR-002 pattern)
+			const isAsyncGenerator =
 				def._resolve?.constructor?.name === "AsyncGeneratorFunction" ||
 				def._resolve?.constructor?.name === "GeneratorFunction";
-			const opType = isSubscription ? "subscription" : "query";
+			const isLive = isLiveQueryDef(def);
+
+			// Live queries need streaming transport (treated as subscription for transport routing)
+			// But operation type stays "query" for semantic correctness
+			const opType = isAsyncGenerator ? "subscription" : "query";
 			const returnType = getReturnTypeName(def._output);
 			const meta: OperationMeta = { type: opType };
 			if (returnType) {
 				meta.returnType = returnType;
 			}
+			// Mark as live for client to use streaming transport
+			if (isLive) {
+				(meta as OperationMeta & { live?: boolean }).live = true;
+			}
 			this.pluginManager.runEnhanceOperationMeta({
 				path: name,
 				type: opType,
@@ -1005,6 +1195,21 @@ class LensServerImpl<
 			setNested(name, meta);
 		}
 
+		for (const [name, def] of Object.entries(this.subscriptions)) {
+			const returnType = getReturnTypeName(def._output);
+			const meta: OperationMeta = { type: "subscription" };
+			if (returnType) {
+				meta.returnType = returnType;
+			}
+			this.pluginManager.runEnhanceOperationMeta({
+				path: name,
+				type: "subscription",
+				meta: meta as unknown as Record<string, unknown>,
+				definition: def,
+			});
+			setNested(name, meta);
+		}
+
 		return result;
 	}
 
@@ -1063,7 +1268,7 @@ export function createApp<
 >(
 	config: LensServerConfig<TContext> & { queries?: Q; mutations?: M },
 ): LensServer & { _types: { queries: Q; mutations: M; context: TContext } } {
-	const server = new LensServerImpl(config) as LensServerImpl<Q, M, TContext>;
+	const server = new LensServerImpl(config) as LensServerImpl<Q, M, SubscriptionsMap, TContext>;
 	return server as unknown as LensServer & {
 		_types: { queries: Q; mutations: M; context: TContext };
 	};