@sylphx/lens-server 2.1.0 → 2.3.0

package/dist/index.d.ts

@@ -41,7 +41,7 @@ declare function extendContext<
 	E extends ContextValue
 >(current: T, extension: E): T & E;
 import { ContextValue as ContextValue3, InferRouterContext as InferRouterContext2, RouterDef as RouterDef2 } from "@sylphx/lens-core";
-import { ContextValue as ContextValue2, EntityDef, InferRouterContext, MutationDef, OptimisticDSL, QueryDef, Resolvers, RouterDef } from "@sylphx/lens-core";
+import { ContextValue as ContextValue2, EntityDef, InferRouterContext, MutationDef, Observable, OptimisticDSL, QueryDef, Resolvers, RouterDef } from "@sylphx/lens-core";
 /**
 * @sylphx/lens-server - Plugin System Types
 *
@@ -555,8 +555,19 @@ interface WebSocketLike {
 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>;
 	/**
 	* Register a client connection.
 	* Call when a client connects via WebSocket/SSE.

package/dist/index.js

@@ -40,7 +40,8 @@ import {
   isEntityDef,
   isMutationDef,
   isQueryDef,
-  toResolverMap
+  toResolverMap,
+  valuesEqual
 } from "@sylphx/lens-core";
 
 // src/plugin/types.ts
@@ -215,6 +216,9 @@ class DataLoader {
 }
 
 // src/server/selection.ts
+function isNestedSelection(value) {
+  return typeof value === "object" && value !== null && (("input" in value) || ("select" in value)) && !Array.isArray(value);
+}
 function extractSelect(value) {
   if (value === true)
     return null;
@@ -257,6 +261,25 @@ function applySelection(data, select) {
   }
   return result;
 }
+function extractNestedInputs(select, prefix = "") {
+  const inputs = new Map;
+  for (const [key, value] of Object.entries(select)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (isNestedSelection(value) && value.input) {
+      inputs.set(path, value.input);
+    }
+    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;
+}
 
 // src/server/create.ts
 function isAsyncIterable(value) {
@@ -337,106 +360,253 @@ class LensServerImpl {
       operations: this.buildOperationsMap()
     };
   }
-  async execute(op) {
+  execute(op) {
     const { path, input } = op;
-    try {
-      if (this.queries[path]) {
-        const data = await this.executeQuery(path, input);
-        return { data };
-      }
-      if (this.mutations[path]) {
-        const data = await this.executeMutation(path, input);
-        return { data };
-      }
-      return { error: new Error(`Operation not found: ${path}`) };
-    } catch (error) {
-      return { error: error instanceof Error ? error : new Error(String(error)) };
+    const isQuery = !!this.queries[path];
+    const isMutation = !!this.mutations[path];
+    if (!isQuery && !isMutation) {
+      return {
+        subscribe: (observer) => {
+          observer.next?.({ error: new Error(`Operation not found: ${path}`) });
+          observer.complete?.();
+          return { unsubscribe: () => {} };
+        }
+      };
     }
+    return this.executeAsObservable(path, input, isQuery);
   }
-  async executeQuery(name, input) {
-    const queryDef = this.queries[name];
-    if (!queryDef)
-      throw new Error(`Query not found: ${name}`);
-    let select;
-    let cleanInput = input;
-    if (input && typeof input === "object" && "$select" in input) {
-      const { $select, ...rest } = input;
-      select = $select;
-      cleanInput = Object.keys(rest).length > 0 ? rest : undefined;
-    }
-    if (queryDef._input && cleanInput !== undefined) {
-      const result = queryDef._input.safeParse(cleanInput);
-      if (!result.success) {
-        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
-      }
-    }
-    const context = await this.contextFactory();
-    try {
-      return await runWithContext(this.ctx, context, async () => {
-        const resolver = queryDef._resolve;
-        if (!resolver)
-          throw new Error(`Query ${name} has no resolver`);
-        const emit = createEmit(() => {});
-        const onCleanup = () => () => {};
-        const lensContext = { ...context, emit, onCleanup };
-        const result = resolver({ input: cleanInput, ctx: lensContext });
-        let data;
-        if (isAsyncIterable(result)) {
-          for await (const value of result) {
-            data = value;
-            break;
+  executeAsObservable(path, input, isQuery) {
+    return {
+      subscribe: (observer) => {
+        let cancelled = false;
+        let currentState;
+        let lastEmittedResult;
+        const cleanups = [];
+        const emitIfChanged = (data) => {
+          if (cancelled)
+            return;
+          if (valuesEqual(data, lastEmittedResult))
+            return;
+          lastEmittedResult = data;
+          observer.next?.({ data });
+        };
+        (async () => {
+          try {
+            const def = isQuery ? this.queries[path] : this.mutations[path];
+            if (!def) {
+              observer.next?.({ error: new Error(`Operation not found: ${path}`) });
+              observer.complete?.();
+              return;
+            }
+            let select;
+            let cleanInput = input;
+            if (isQuery && input && typeof input === "object" && "$select" in input) {
+              const { $select, ...rest } = input;
+              select = $select;
+              cleanInput = Object.keys(rest).length > 0 ? rest : undefined;
+            }
+            if (def._input && cleanInput !== undefined) {
+              const result = def._input.safeParse(cleanInput);
+              if (!result.success) {
+                observer.next?.({
+                  error: new Error(`Invalid input: ${JSON.stringify(result.error)}`)
+                });
+                observer.complete?.();
+                return;
+              }
+            }
+            const context = await this.contextFactory();
+            await runWithContext(this.ctx, context, async () => {
+              const resolver = def._resolve;
+              if (!resolver) {
+                observer.next?.({ error: new Error(`Operation ${path} has no resolver`) });
+                observer.complete?.();
+                return;
+              }
+              let emitProcessing = false;
+              const emitQueue = [];
+              const processEmitQueue = async () => {
+                if (emitProcessing || cancelled)
+                  return;
+                emitProcessing = true;
+                while (emitQueue.length > 0 && !cancelled) {
+                  const command = emitQueue.shift();
+                  currentState = this.applyEmitCommand(command, currentState);
+                  const fieldEmitFactory = isQuery ? this.createFieldEmitFactory(() => currentState, (state) => {
+                    currentState = state;
+                  }, emitIfChanged, select, context, onCleanup) : undefined;
+                  const processed = isQuery ? await this.processQueryResult(path, currentState, select, context, onCleanup, fieldEmitFactory) : currentState;
+                  emitIfChanged(processed);
+                }
+                emitProcessing = false;
+              };
+              const emitHandler = (command) => {
+                if (cancelled)
+                  return;
+                emitQueue.push(command);
+                processEmitQueue().catch((err) => {
+                  if (!cancelled) {
+                    observer.next?.({ error: err instanceof Error ? err : new Error(String(err)) });
+                  }
+                });
+              };
+              const emit = createEmit(emitHandler);
+              const onCleanup = (fn) => {
+                cleanups.push(fn);
+                return () => {
+                  const idx = cleanups.indexOf(fn);
+                  if (idx >= 0)
+                    cleanups.splice(idx, 1);
+                };
+              };
+              const createFieldEmit = isQuery ? this.createFieldEmitFactory(() => currentState, (state) => {
+                currentState = state;
+              }, emitIfChanged, select, context, onCleanup) : undefined;
+              const lensContext = { ...context, emit, onCleanup };
+              const result = resolver({ input: cleanInput, ctx: lensContext });
+              if (isAsyncIterable(result)) {
+                for await (const value of result) {
+                  if (cancelled)
+                    break;
+                  currentState = value;
+                  const processed = await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit);
+                  emitIfChanged(processed);
+                }
+                if (!cancelled) {
+                  observer.complete?.();
+                }
+              } else {
+                const value = await result;
+                currentState = value;
+                const processed = isQuery ? await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit) : value;
+                emitIfChanged(processed);
+              }
+            });
+          } catch (error) {
+            if (!cancelled) {
+              observer.next?.({ error: error instanceof Error ? error : new Error(String(error)) });
+              observer.complete?.();
+            }
+          } finally {
+            this.clearLoaders();
           }
-          if (data === undefined) {
-            throw new Error(`Query ${name} returned empty stream`);
+        })();
+        return {
+          unsubscribe: () => {
+            cancelled = true;
+            for (const fn of cleanups) {
+              fn();
+            }
           }
-        } else {
-          data = await result;
+        };
+      }
+    };
+  }
+  applyEmitCommand(command, state) {
+    switch (command.type) {
+      case "full":
+        if (command.replace) {
+          return command.data;
         }
-        return this.processQueryResult(name, data, select);
-      });
-    } finally {
-      this.clearLoaders();
+        if (state && typeof state === "object" && typeof command.data === "object") {
+          return { ...state, ...command.data };
+        }
+        return command.data;
+      case "field":
+        if (state && typeof state === "object") {
+          return {
+            ...state,
+            [command.field]: command.update.data
+          };
+        }
+        return { [command.field]: command.update.data };
+      case "batch":
+        if (state && typeof state === "object") {
+          const result = { ...state };
+          for (const update of command.updates) {
+            result[update.field] = update.update.data;
+          }
+          return result;
+        }
+        return state;
+      case "array": {
+        const arr = Array.isArray(state) ? [...state] : [];
+        const op = command.operation;
+        switch (op.op) {
+          case "push":
+            return [...arr, op.item];
+          case "unshift":
+            return [op.item, ...arr];
+          case "insert":
+            arr.splice(op.index, 0, op.item);
+            return arr;
+          case "remove":
+            arr.splice(op.index, 1);
+            return arr;
+          case "update":
+            arr[op.index] = op.item;
+            return arr;
+          default:
+            return arr;
+        }
+      }
+      default:
+        return state;
     }
   }
-  async executeMutation(name, input) {
-    const mutationDef = this.mutations[name];
-    if (!mutationDef)
-      throw new Error(`Mutation not found: ${name}`);
-    if (mutationDef._input) {
-      const result = mutationDef._input.safeParse(input);
-      if (!result.success) {
-        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
-      }
+  createFieldEmitFactory(getCurrentState, setCurrentState, notifyObserver, select, context, onCleanup) {
+    return (fieldPath) => {
+      if (!fieldPath)
+        return;
+      return (newValue) => {
+        const state = getCurrentState();
+        if (!state || typeof state !== "object")
+          return;
+        const updatedState = this.setFieldByPath(state, fieldPath, newValue);
+        setCurrentState(updatedState);
+        (async () => {
+          try {
+            const nestedInputs = select ? extractNestedInputs(select) : undefined;
+            const processed = await this.resolveEntityFields(updatedState, nestedInputs, context, "", onCleanup, this.createFieldEmitFactory(getCurrentState, setCurrentState, notifyObserver, select, context, onCleanup));
+            const result = select ? applySelection(processed, select) : processed;
+            notifyObserver(result);
+          } catch (err) {
+            console.error(`Field emit error at path "${fieldPath}":`, err);
+          }
+        })();
+      };
+    };
+  }
+  setFieldByPath(obj, path, value) {
+    const parts = path.split(".");
+    if (parts.length === 1) {
+      return { ...obj, [path]: value };
     }
-    const context = await this.contextFactory();
-    try {
-      return await runWithContext(this.ctx, context, async () => {
-        const resolver = mutationDef._resolve;
-        if (!resolver)
-          throw new Error(`Mutation ${name} has no resolver`);
-        const emit = createEmit(() => {});
-        const onCleanup = () => () => {};
-        const lensContext = { ...context, emit, onCleanup };
-        return await resolver({ input, ctx: lensContext });
-      });
-    } finally {
-      this.clearLoaders();
+    const [first, ...rest] = parts;
+    const nested = obj[first];
+    if (nested && typeof nested === "object") {
+      return {
+        ...obj,
+        [first]: this.setFieldByPath(nested, rest.join("."), value)
+      };
     }
+    return obj;
   }
-  async processQueryResult(_operationName, data, select) {
+  async processQueryResult(_operationName, data, select, context, onCleanup, createFieldEmit) {
     if (!data)
       return data;
-    const processed = await this.resolveEntityFields(data);
+    const nestedInputs = select ? extractNestedInputs(select) : undefined;
+    const processed = await this.resolveEntityFields(data, nestedInputs, context, "", onCleanup, createFieldEmit);
     if (select) {
       return applySelection(processed, select);
     }
     return processed;
   }
-  async resolveEntityFields(data) {
+  async resolveEntityFields(data, nestedInputs, context, fieldPath = "", onCleanup, createFieldEmit) {
     if (!data || !this.resolverMap)
       return data;
     if (Array.isArray(data)) {
-      return Promise.all(data.map((item) => this.resolveEntityFields(item)));
+      return Promise.all(data.map((item) => this.resolveEntityFields(item, nestedInputs, context, fieldPath, onCleanup, createFieldEmit)));
     }
     if (typeof data !== "object")
       return data;
@@ -452,15 +622,31 @@ class LensServerImpl {
       const field = String(fieldName);
       if (resolverDef.isExposed(field))
         continue;
+      const currentPath = fieldPath ? `${fieldPath}.${field}` : field;
+      const args = nestedInputs?.get(currentPath) ?? {};
+      const hasArgs = Object.keys(args).length > 0;
       const existingValue = result[field];
       if (existingValue !== undefined) {
-        result[field] = await this.resolveEntityFields(existingValue);
+        result[field] = await this.resolveEntityFields(existingValue, nestedInputs, context, currentPath, onCleanup, createFieldEmit);
         continue;
       }
-      const loaderKey = `${typeName}.${field}`;
-      const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field);
-      result[field] = await loader.load(obj);
-      result[field] = await this.resolveEntityFields(result[field]);
+      if (hasArgs || context) {
+        try {
+          const extendedCtx = {
+            ...context ?? {},
+            emit: createFieldEmit(currentPath),
+            onCleanup
+          };
+          result[field] = await resolverDef.resolveField(field, obj, args, extendedCtx);
+        } catch {
+          result[field] = null;
+        }
+      } else {
+        const loaderKey = `${typeName}.${field}`;
+        const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field);
+        result[field] = await loader.load(obj);
+      }
+      result[field] = await this.resolveEntityFields(result[field], nestedInputs, context, currentPath, onCleanup, createFieldEmit);
     }
     return result;
   }
@@ -469,15 +655,23 @@ class LensServerImpl {
       return obj.__typename;
     if ("_type" in obj)
       return obj._type;
+    let bestMatch;
     for (const [name, def] of Object.entries(this.entities)) {
-      if (isEntityDef(def) && this.matchesEntity(obj, def)) {
-        return name;
+      if (!isEntityDef(def))
+        continue;
+      const score = this.getEntityMatchScore(obj, def);
+      if (score >= 0.5 && (!bestMatch || score > bestMatch.score)) {
+        bestMatch = { name, score };
       }
     }
-    return;
+    return bestMatch?.name;
   }
-  matchesEntity(obj, entityDef) {
-    return "id" in obj || entityDef._name in obj;
+  getEntityMatchScore(obj, entityDef) {
+    const fieldNames = Object.keys(entityDef.fields);
+    if (fieldNames.length === 0)
+      return 0;
+    const matchingFields = fieldNames.filter((field) => (field in obj));
+    return matchingFields.length / fieldNames.length;
   }
   getOrCreateLoaderForField(loaderKey, resolverDef, fieldName) {
     let loader = this.loaders.get(loaderKey);
@@ -716,6 +910,7 @@ function createSSEHandler(config = {}) {
 }
 
 // src/handlers/http.ts
+import { firstValueFrom } from "@sylphx/lens-core";
 function createHTTPHandler(server, options = {}) {
   const { pathPrefix = "", cors } = options;
   const corsHeaders = {
@@ -755,10 +950,10 @@ function createHTTPHandler(server, options = {}) {
             }
           });
         }
-        const result2 = await server.execute({
+        const result2 = await firstValueFrom(server.execute({
           path: operationPath2,
           input: body.input
-        });
+        }));
         if (result2.error) {
           return new Response(JSON.stringify({ error: result2.error.message }), {
             status: 500,
@@ -826,6 +1021,7 @@ function createHandler(server, options = {}) {
   return result;
 }
 // src/handlers/framework.ts
+import { firstValueFrom as firstValueFrom2 } from "@sylphx/lens-core";
 function createServerClientProxy(server) {
   function createProxy(path) {
     return new Proxy(() => {}, {
@@ -839,7 +1035,7 @@ function createServerClientProxy(server) {
       },
       async apply(_, __, args) {
         const input = args[0];
-        const result = await server.execute({ path, input });
+        const result = await firstValueFrom2(server.execute({ path, input }));
         if (result.error) {
           throw result.error;
         }
@@ -853,7 +1049,7 @@ async function handleWebQuery(server, path, url) {
   try {
     const inputParam = url.searchParams.get("input");
     const input = inputParam ? JSON.parse(inputParam) : undefined;
-    const result = await server.execute({ path, input });
+    const result = await firstValueFrom2(server.execute({ path, input }));
     if (result.error) {
       return Response.json({ error: result.error.message }, { status: 400 });
     }
@@ -866,7 +1062,7 @@ async function handleWebMutation(server, path, request) {
   try {
     const body = await request.json();
     const input = body.input;
-    const result = await server.execute({ path, input });
+    const result = await firstValueFrom2(server.execute({ path, input }));
     if (result.error) {
       return Response.json({ error: result.error.message }, { status: 400 });
     }
@@ -938,6 +1134,9 @@ function createFrameworkHandler(server, options = {}) {
   };
 }
 // src/handlers/ws.ts
+import {
+  firstValueFrom as firstValueFrom3
+} from "@sylphx/lens-core";
 function createWSHandler(server, options = {}) {
   const { logger = {} } = options;
   const connections = new Map;
@@ -1014,7 +1213,7 @@ function createWSHandler(server, options = {}) {
     const { id, operation, input, fields } = message;
     let result;
     try {
-      result = await server.execute({ path: operation, input });
+      result = await firstValueFrom3(server.execute({ path: operation, input }));
       if (result.error) {
         conn.ws.send(JSON.stringify({
           type: "error",
@@ -1140,10 +1339,10 @@ function createWSHandler(server, options = {}) {
   }
   async function handleQuery(conn, message) {
     try {
-      const result = await server.execute({
+      const result = await firstValueFrom3(server.execute({
         path: message.operation,
         input: message.input
-      });
+      }));
       if (result.error) {
         conn.ws.send(JSON.stringify({
           type: "error",
@@ -1168,10 +1367,10 @@ function createWSHandler(server, options = {}) {
   }
   async function handleMutation(conn, message) {
     try {
-      const result = await server.execute({
+      const result = await firstValueFrom3(server.execute({
         path: message.operation,
         input: message.input
-      });
+      }));
       if (result.error) {
         conn.ws.send(JSON.stringify({
           type: "error",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "2.1.0",
+	"version": "2.3.0",
 	"description": "Server runtime for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -30,7 +30,7 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-core": "^2.0.1"
+		"@sylphx/lens-core": "^2.2.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.9.3",