@sylphx/lens-server 2.2.0 → 2.3.0

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) {
@@ -357,7 +380,16 @@ class LensServerImpl {
       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];
@@ -391,11 +423,32 @@ class LensServerImpl {
                 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;
-                currentState = this.applyEmitCommand(command, currentState);
-                observer.next?.({ data: currentState });
+                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) => {
@@ -406,6 +459,9 @@ class LensServerImpl {
                     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)) {
@@ -413,8 +469,8 @@ class LensServerImpl {
                   if (cancelled)
                     break;
                   currentState = value;
-                  const processed = await this.processQueryResult(path, value, select);
-                  observer.next?.({ data: processed });
+                  const processed = await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit);
+                  emitIfChanged(processed);
                 }
                 if (!cancelled) {
                   observer.complete?.();
@@ -422,10 +478,8 @@ class LensServerImpl {
               } else {
                 const value = await result;
                 currentState = value;
-                const processed = isQuery ? await this.processQueryResult(path, value, select) : value;
-                if (!cancelled) {
-                  observer.next?.({ data: processed });
-                }
+                const processed = isQuery ? await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit) : value;
+                emitIfChanged(processed);
               }
             });
           } catch (error) {
@@ -500,20 +554,59 @@ class LensServerImpl {
         return state;
     }
   }
-  async processQueryResult(_operationName, data, select) {
+  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 [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, 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;
@@ -529,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;
   }
@@ -546,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);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "2.2.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.1.0"
+		"@sylphx/lens-core": "^2.2.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.9.3",