@sylphx/lens-server 2.0.1 → 2.2.0

package/src/server/selection.ts

@@ -4,12 +4,53 @@
  * Field selection logic for query results.
  */
 
-import type { SelectionObject } from "./types.js";
+import type { NestedSelection, SelectionObject } from "./types.js";
+
+/**
+ * Check if a value is a NestedSelection with input.
+ */
+function isNestedSelection(value: unknown): value is NestedSelection {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		("input" in value || "select" in value) &&
+		!Array.isArray(value)
+	);
+}
+
+/**
+ * Extract the select object from a selection value.
+ * Handles: true, SelectionObject, { select: ... }, { input: ..., select: ... }
+ */
+function extractSelect(value: unknown): SelectionObject | null {
+	if (value === true) return null;
+	if (typeof value !== "object" || value === null) return null;
+
+	const obj = value as Record<string, unknown>;
+
+	// { input?: ..., select?: ... } pattern
+	if ("input" in obj || ("select" in obj && typeof obj.select === "object")) {
+		return (obj.select as SelectionObject) ?? null;
+	}
+
+	// { select: ... } pattern (without input)
+	if ("select" in obj && typeof obj.select === "object") {
+		return obj.select as SelectionObject;
+	}
+
+	// Direct SelectionObject
+	return value as SelectionObject;
+}
 
 /**
  * Apply field selection to data.
  * Recursively filters data to only include selected fields.
  *
+ * Supports:
+ * - `field: true` - Include field as-is
+ * - `field: { select: {...} }` - Nested selection
+ * - `field: { input: {...}, select: {...} }` - Nested with input (input passed to resolvers)
+ *
  * @param data - The data to filter
  * @param select - Selection object specifying which fields to include
  * @returns Filtered data with only selected fields
@@ -35,10 +76,48 @@ export function applySelection(data: unknown, select: SelectionObject): unknown
 		if (value === true) {
 			result[key] = obj[key];
 		} else if (typeof value === "object" && value !== null) {
-			const nestedSelect = "select" in value ? value.select : value;
-			result[key] = applySelection(obj[key], nestedSelect as SelectionObject);
+			const nestedSelect = extractSelect(value);
+			if (nestedSelect) {
+				result[key] = applySelection(obj[key], nestedSelect);
+			} else {
+				// No nested select means include the whole field
+				result[key] = obj[key];
+			}
 		}
 	}
 
 	return result;
 }
+
+/**
+ * Extract nested inputs from a selection object.
+ * Returns a map of field paths to their input params.
+ * Used by resolvers to fetch nested data with the right params.
+ */
+export function extractNestedInputs(
+	select: SelectionObject,
+	prefix = "",
+): Map<string, Record<string, unknown>> {
+	const inputs = new Map<string, Record<string, unknown>>();
+
+	for (const [key, value] of Object.entries(select)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+
+		if (isNestedSelection(value) && value.input) {
+			inputs.set(path, value.input);
+		}
+
+		// Recurse into nested selections
+		if (typeof value === "object" && value !== null) {
+			const nestedSelect = extractSelect(value);
+			if (nestedSelect) {
+				const nestedInputs = extractNestedInputs(nestedSelect, path);
+				for (const [nestedPath, nestedInput] of nestedInputs) {
+					inputs.set(nestedPath, nestedInput);
+				}
+			}
+		}
+	}
+
+	return inputs;
+}

package/src/server/types.ts

@@ -9,6 +9,7 @@ import type {
 	EntityDef,
 	InferRouterContext,
 	MutationDef,
+	Observable,
 	OptimisticDSL,
 	QueryDef,
 	Resolvers,
@@ -20,9 +21,26 @@ import type { PluginManager, ServerPlugin } from "../plugin/types.js";
 // Selection Types
 // =============================================================================
 
-/** Selection object type for nested field selection */
+/**
+ * Nested selection object with optional input.
+ * Used for relations that need their own params.
+ */
+export interface NestedSelection {
+	/** Input/params for this nested query */
+	input?: Record<string, unknown>;
+	/** Field selection for this nested query */
+	select?: SelectionObject;
+}
+
+/**
+ * Selection object for field selection.
+ * Supports:
+ * - `true` - Select this field
+ * - `{ select: {...} }` - Nested selection only
+ * - `{ input: {...}, select?: {...} }` - Nested with input params
+ */
 export interface SelectionObject {
-	[key: string]: boolean | SelectionObject | { select: SelectionObject };
+	[key: string]: boolean | SelectionObject | { select: SelectionObject } | NestedSelection;
 }
 
 // =============================================================================
@@ -164,8 +182,20 @@ export interface WebSocketLike {
 export interface LensServer {
 	/** Get server metadata for transport handshake */
 	getMetadata(): ServerMetadata;
-	/** Execute operation - auto-detects query vs mutation */
-	execute(op: LensOperation): Promise<LensResult>;
+
+	/**
+	 * Execute operation - auto-detects query vs mutation.
+	 *
+	 * Always returns Observable<LensResult>:
+	 * - One-shot: emits once, then completes
+	 * - Streaming: emits multiple times (AsyncIterable or emit-based)
+	 *
+	 * Usage:
+	 * - HTTP: `await firstValueFrom(server.execute(op))`
+	 * - WS/SSE: `server.execute(op).subscribe(...)`
+	 * - direct: pass through Observable directly
+	 */
+	execute(op: LensOperation): Observable<LensResult>;
 
 	// =========================================================================
 	// Subscription Support (Optional - used by WS/SSE handlers)