@sylphx/lens-server 1.3.2 → 1.5.0

package/src/server/create.ts

@@ -10,27 +10,24 @@
 
 import {
 	type ContextValue,
+	createContext,
+	createEmit,
+	createUpdate,
 	type EmitCommand,
 	type EntityDef,
-	type EntityDefinition,
-	type EntityResolvers,
-	type EntityResolversDefinition,
 	type FieldType,
+	flattenRouter,
 	type InferRouterContext,
+	isMutationDef,
+	isQueryDef,
 	type MutationDef,
 	type QueryDef,
-	type RelationDef,
-	type RelationTypeWithForeignKey,
+	type ResolverDef,
+	type Resolvers,
 	type RouterDef,
-	type Update,
-	createContext,
-	createEmit,
-	createUpdate,
-	flattenRouter,
-	isBatchResolver,
-	isMutationDef,
-	isQueryDef,
 	runWithContext,
+	toResolverMap,
+	type Update,
 } from "@sylphx/lens-core";
 
 /** Selection object type for nested field selection */
@@ -45,7 +42,6 @@ import { GraphStateManager } from "../state/graph-state-manager";
 // =============================================================================
 
 /** Entity map type */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type EntitiesMap = Record<string, EntityDef<string, any>>;
 
 /** Queries map type */
@@ -54,15 +50,12 @@ export type QueriesMap = Record<string, QueryDef<unknown, unknown>>;
 /** Mutations map type */
 export type MutationsMap = Record<string, MutationDef<unknown, unknown>>;
 
-/** Relations array type */
-export type RelationsArray = RelationDef<
-	EntityDef<string, EntityDefinition>,
-	Record<string, RelationTypeWithForeignKey>
->[];
+/** Resolver map type for internal use (uses any to avoid complex variance issues) */
+type ResolverMap = Map<string, ResolverDef<any, any, any>>;
 
 /** Operation metadata for handshake */
 export interface OperationMeta {
-	type: "query" | "mutation";
+	type: "query" | "mutation" | "subscription";
 	optimistic?: unknown; // OptimisticDSL - sent as JSON
 }
 
@@ -71,6 +64,13 @@ export type OperationsMap = {
 	[key: string]: OperationMeta | OperationsMap;
 };
 
+/** Logger interface for server */
+export interface LensLogger {
+	info?: (message: string, ...args: unknown[]) => void;
+	warn?: (message: string, ...args: unknown[]) => void;
+	error?: (message: string, ...args: unknown[]) => void;
+}
+
 /** Server configuration */
 export interface LensServerConfig<
 	TContext extends ContextValue = ContextValue,
@@ -78,16 +78,16 @@ export interface LensServerConfig<
 > {
 	/** Entity definitions */
 	entities?: EntitiesMap;
-	/** Relation definitions */
-	relations?: RelationsArray;
 	/** 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>;
+	/** Field resolvers array (use lens() factory to create) */
+	resolvers?: Resolvers;
+	/** Logger for server messages (default: silent) */
+	logger?: LensLogger;
 	/** Context factory - must return the context type expected by the router */
 	context?: (req?: unknown) => TContext | Promise<TContext>;
 	/** Server version */
@@ -149,12 +149,6 @@ export interface WebSocketLike {
 	onerror?: ((error: unknown) => void) | null;
 }
 
-/** Emit context for streaming resolvers */
-interface EmitContext<T> {
-	emit: (data: T) => void;
-	onCleanup: (fn: () => void) => () => void;
-}
-
 // =============================================================================
 // Protocol Messages
 // =============================================================================
@@ -285,11 +279,11 @@ class DataLoader<K, V> {
 			keys.forEach((key, index) => {
 				const callbacks = batch.get(key)!;
 				const result = results[index] ?? null;
-				callbacks.forEach(({ resolve }) => resolve(result));
+				for (const { resolve } of callbacks) resolve(result);
 			});
 		} catch (error) {
 			for (const callbacks of batch.values()) {
-				callbacks.forEach(({ reject }) => reject(error as Error));
+				for (const { reject } of callbacks) reject(error as Error);
 			}
 		}
 	}
@@ -303,6 +297,9 @@ class DataLoader<K, V> {
 // Lens Server Implementation
 // =============================================================================
 
+/** No-op logger (default - silent) */
+const noopLogger: LensLogger = {};
+
 class LensServerImpl<
 	Q extends QueriesMap = QueriesMap,
 	M extends MutationsMap = MutationsMap,
@@ -312,9 +309,10 @@ class LensServerImpl<
 	private queries: Q;
 	private mutations: M;
 	private entities: EntitiesMap;
-	private resolvers?: EntityResolvers<EntityResolversDefinition>;
+	private resolverMap?: ResolverMap;
 	private contextFactory: (req?: unknown) => TContext | Promise<TContext>;
 	private version: string;
+	private logger: LensLogger;
 	private ctx = createContext<TContext>();
 
 	/** GraphStateManager for per-client state tracking */
@@ -350,9 +348,11 @@ class LensServerImpl<
 		this.queries = queries as Q;
 		this.mutations = mutations as M;
 		this.entities = config.entities ?? {};
-		this.resolvers = config.resolvers;
+		// Normalize resolvers input (array or registry) to internal map
+		this.resolverMap = config.resolvers ? toResolverMap(config.resolvers) : undefined;
 		this.contextFactory = config.context ?? (() => ({}) as TContext);
 		this.version = config.version ?? "1.0.0";
+		this.logger = config.logger ?? noopLogger;
 
 		// Inject entity names from keys (if not already set)
 		for (const [name, def] of Object.entries(this.entities)) {
@@ -475,7 +475,7 @@ class LensServerImpl<
 		};
 
 		// Add queries
-		for (const [name, def] of Object.entries(this.queries)) {
+		for (const [name, _def] of Object.entries(this.queries)) {
 			setNested(name, { type: "query" });
 		}
 
@@ -787,7 +787,7 @@ class LensServerImpl<
 			try {
 				cleanup();
 			} catch (e) {
-				console.error("Cleanup error:", e);
+				this.logger.error?.("Cleanup error:", e);
 			}
 		}
 
@@ -869,7 +869,7 @@ class LensServerImpl<
 				try {
 					cleanup();
 				} catch (e) {
-					console.error("Cleanup error:", e);
+					this.logger.error?.("Cleanup error:", e);
 				}
 			}
 		}
@@ -1074,7 +1074,7 @@ class LensServerImpl<
 			},
 		});
 
-		console.log(`Lens server listening on port ${port}`);
+		this.logger.info?.(`Lens server listening on port ${port}`);
 	}
 
 	async close(): Promise<void> {
@@ -1227,42 +1227,41 @@ class LensServerImpl<
 
 	/**
 	 * Execute entity resolvers for nested data.
-	 * Processes the selection object and resolves relation fields.
+	 * Processes the selection object and resolves relation fields using new resolver() pattern.
 	 */
 	private async executeEntityResolvers<T>(
 		entityName: string,
 		data: T,
 		select?: SelectionObject,
 	): Promise<T> {
-		if (!data || !select || !this.resolvers) return data;
+		if (!data || !select || !this.resolverMap) return data;
+
+		// Get resolver for this entity
+		const resolverDef = this.resolverMap.get(entityName);
+		if (!resolverDef) return data;
 
 		const result = { ...(data as Record<string, unknown>) };
+		const context = await this.contextFactory();
 
 		for (const [fieldName, fieldSelect] of Object.entries(select)) {
 			if (fieldSelect === false || fieldSelect === true) continue;
 
-			// Check if this field has an entity resolver
-			const resolver = this.resolvers.getResolver(entityName, fieldName);
-			if (!resolver) continue;
-
-			// Execute resolver (with batching if available)
-			if (isBatchResolver(resolver)) {
-				// Use DataLoader for batching
-				const loaderKey = `${entityName}.${fieldName}`;
-				if (!this.loaders.has(loaderKey)) {
-					this.loaders.set(
-						loaderKey,
-						new DataLoader(async (parents: unknown[]) => {
-							return resolver.batch(parents);
-						}),
-					);
-				}
-				const loader = this.loaders.get(loaderKey)!;
-				result[fieldName] = await loader.load(data);
-			} else {
-				// Simple resolver
-				result[fieldName] = await resolver(data);
-			}
+			// Check if this field has a resolver
+			if (!resolverDef.hasField(fieldName)) continue;
+
+			// Extract field args from selection
+			const fieldArgs =
+				typeof fieldSelect === "object" && fieldSelect !== null && "args" in fieldSelect
+					? ((fieldSelect as { args?: Record<string, unknown> }).args ?? {})
+					: {};
+
+			// Execute field resolver with args
+			result[fieldName] = await resolverDef.resolveField(
+				fieldName,
+				data as any,
+				fieldArgs,
+				context as any,
+			);
 
 			// Recursively resolve nested selections
 			const nestedSelect = (fieldSelect as { select?: SelectionObject }).select;
@@ -1376,7 +1375,7 @@ class LensServerImpl<
 						value,
 					);
 				} catch (error) {
-					console.warn(`Failed to serialize field ${entityName}.${fieldName}:`, error);
+					this.logger.warn?.(`Failed to serialize field ${entityName}.${fieldName}:`, error);
 					result[fieldName] = value;
 				}
 			} else {
@@ -1408,7 +1407,7 @@ class LensServerImpl<
 					let result = item;
 
 					// Execute entity resolvers for nested data
-					if (select && this.resolvers) {
+					if (select && this.resolverMap) {
 						result = await this.executeEntityResolvers(entityName, item, select);
 					}
 
@@ -1432,7 +1431,7 @@ class LensServerImpl<
 		let result: T = data;
 
 		// Execute entity resolvers for nested data
-		if (select && this.resolvers) {
+		if (select && this.resolverMap) {
 			result = (await this.executeEntityResolvers(entityName, data, select)) as T;
 		}
 
@@ -1512,22 +1511,20 @@ function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T> {
 /**
  * Infer input type from a query/mutation definition
  */
-export type InferInput<T> = T extends QueryDef<infer I, unknown>
-	? I extends void
-		? void
-		: I
-	: T extends MutationDef<infer I, unknown>
-		? I
-		: never;
+export type InferInput<T> =
+	T extends QueryDef<infer I, unknown>
+		? I extends void
+			? void
+			: I
+		: T extends MutationDef<infer I, unknown>
+			? I
+			: never;
 
 /**
  * Infer output type from a query/mutation definition
  */
-export type InferOutput<T> = T extends QueryDef<unknown, infer O>
-	? O
-	: T extends MutationDef<unknown, infer O>
-		? O
-		: never;
+export type InferOutput<T> =
+	T extends QueryDef<unknown, infer O> ? O : T extends MutationDef<unknown, infer O> ? O : never;
 
 /**
  * API type for client inference
@@ -1544,9 +1541,7 @@ export type InferOutput<T> = T extends QueryDef<unknown, infer O>
  * const client = createClient<Api>({ links: [...] });
  * ```
  */
-export type InferApi<T extends LensServer> = T extends LensServerImpl<infer Q, infer M>
-	? { queries: Q; mutations: M }
-	: never;
+export type InferApi<T> = T extends { _types: infer Types } ? Types : never;
 
 // =============================================================================
 // Factory
@@ -1561,11 +1556,11 @@ export type ServerConfigWithInferredContext<
 	M extends MutationsMap = MutationsMap,
 > = {
 	entities?: EntitiesMap;
-	relations?: RelationsArray;
 	router: TRouter;
 	queries?: Q;
 	mutations?: M;
-	resolvers?: EntityResolvers<EntityResolversDefinition>;
+	/** Field resolvers array */
+	resolvers?: Resolvers;
 	/** Context factory - type is inferred from router's procedures */
 	context?: (req?: unknown) => InferRouterContext<TRouter> | Promise<InferRouterContext<TRouter>>;
 	version?: string;
@@ -1580,11 +1575,11 @@ export type ServerConfigLegacy<
 	M extends MutationsMap = MutationsMap,
 > = {
 	entities?: EntitiesMap;
-	relations?: RelationsArray;
 	router?: undefined;
 	queries?: Q;
 	mutations?: M;
-	resolvers?: EntityResolvers<EntityResolversDefinition>;
+	/** Field resolvers array */
+	resolvers?: Resolvers;
 	context?: (req?: unknown) => TContext | Promise<TContext>;
 	version?: string;
 };
@@ -1613,7 +1608,9 @@ export function createServer<
 	M extends MutationsMap = MutationsMap,
 >(
 	config: ServerConfigWithInferredContext<TRouter, Q, M>,
-): LensServer & { _types: { queries: Q; mutations: M; context: InferRouterContext<TRouter> } };
+): LensServer & {
+	_types: { router: TRouter; queries: Q; mutations: M; context: InferRouterContext<TRouter> };
+};
 
 export function createServer<
 	TContext extends ContextValue = ContextValue,

package/src/sse/handler.ts

@@ -69,7 +69,7 @@ export class SSEHandler {
 	 * Handle new SSE connection
 	 * Returns a Response with SSE stream
 	 */
-	handleConnection(req?: Request): Response {
+	handleConnection(_req?: Request): Response {
 		const clientId = `sse_${++this.clientCounter}_${Date.now()}`;
 		const encoder = new TextEncoder();