@sylphx/lens-server 2.13.2 → 2.14.0

package/dist/index.d.ts

@@ -536,11 +536,11 @@ interface LensOperation {
 	path: string;
 	input?: unknown;
 }
-/** Result from operation execution */
-interface LensResult<T = unknown> {
-	data?: T;
-	error?: Error;
-}
+/**
+* Result from operation execution.
+* Uses the new Message protocol format.
+*/
+type LensResult<T = unknown> = import("@sylphx/lens-core").Message<T>;
 /**
 * Client send function type for subscription updates.
 */

package/dist/index.js

@@ -35,7 +35,6 @@ function extendContext(current, extension) {
 }
 // src/server/create.ts
 import {
-  applyUpdate,
   collectModelsFromOperations,
   collectModelsFromRouter,
   createEmit,
@@ -49,6 +48,7 @@ import {
   isMutationDef,
   isQueryDef,
   mergeModelCollections,
+  toOps,
   valuesEqual
 } from "@sylphx/lens-core";
 
@@ -293,45 +293,6 @@ function extractNestedInputs(select, prefix = "") {
 function isAsyncIterable(value) {
   return value != null && typeof value === "object" && Symbol.asyncIterator in value;
 }
-
-class RingBuffer {
-  capacity;
-  buffer;
-  head = 0;
-  tail = 0;
-  count = 0;
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.buffer = new Array(capacity).fill(null);
-  }
-  get size() {
-    return this.count;
-  }
-  get isEmpty() {
-    return this.count === 0;
-  }
-  enqueue(item) {
-    let dropped = false;
-    if (this.count >= this.capacity) {
-      this.head = (this.head + 1) % this.capacity;
-      this.count--;
-      dropped = true;
-    }
-    this.buffer[this.tail] = item;
-    this.tail = (this.tail + 1) % this.capacity;
-    this.count++;
-    return dropped;
-  }
-  dequeue() {
-    if (this.count === 0)
-      return null;
-    const item = this.buffer[this.head];
-    this.buffer[this.head] = null;
-    this.head = (this.head + 1) % this.capacity;
-    this.count--;
-    return item;
-  }
-}
 var noopLogger = {};
 
 class LensServerImpl {
@@ -520,7 +481,11 @@ class LensServerImpl {
     if (!isQuery && !isMutation) {
       return {
         subscribe: (observer) => {
-          observer.next?.({ error: new Error(`Operation not found: ${path}`) });
+          observer.next?.({
+            $: "error",
+            error: `Operation not found: ${path}`,
+            code: "NOT_FOUND"
+          });
           observer.complete?.();
           return { unsubscribe: () => {} };
         }
@@ -532,7 +497,6 @@ class LensServerImpl {
     return {
       subscribe: (observer) => {
         let cancelled = false;
-        let currentState;
         let lastEmittedResult;
         let lastEmittedHash;
         const cleanups = [];
@@ -545,13 +509,17 @@ class LensServerImpl {
           }
           lastEmittedResult = data;
           lastEmittedHash = dataHash;
-          observer.next?.({ data });
+          observer.next?.({ $: "snapshot", data });
         };
         (async () => {
           try {
             const def = isQuery ? this.queries[path] : this.mutations[path];
             if (!def) {
-              observer.next?.({ error: new Error(`Operation not found: ${path}`) });
+              observer.next?.({
+                $: "error",
+                error: `Operation not found: ${path}`,
+                code: "NOT_FOUND"
+              });
               observer.complete?.();
               return;
             }
@@ -566,7 +534,9 @@ class LensServerImpl {
               const result = def._input.safeParse(cleanInput);
               if (!result.success) {
                 observer.next?.({
-                  error: new Error(`Invalid input: ${JSON.stringify(result.error)}`)
+                  $: "error",
+                  error: `Invalid input: ${JSON.stringify(result.error)}`,
+                  code: "VALIDATION_ERROR"
                 });
                 observer.complete?.();
                 return;
@@ -576,39 +546,19 @@ class LensServerImpl {
             await runWithContext(this.ctx, context, async () => {
               const resolver = def._resolve;
               if (!resolver) {
-                observer.next?.({ error: new Error(`Operation ${path} has no resolver`) });
+                observer.next?.({
+                  $: "error",
+                  error: `Operation ${path} has no resolver`,
+                  code: "NO_RESOLVER"
+                });
                 observer.complete?.();
                 return;
               }
-              let emitProcessing = false;
-              const MAX_EMIT_QUEUE_SIZE = 100;
-              const emitQueue = new RingBuffer(MAX_EMIT_QUEUE_SIZE);
-              const processEmitQueue = async () => {
-                if (emitProcessing || cancelled)
-                  return;
-                emitProcessing = true;
-                let command = emitQueue.dequeue();
-                while (command !== null && !cancelled) {
-                  this.clearLoaders();
-                  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);
-                  command = emitQueue.dequeue();
-                }
-                emitProcessing = false;
-              };
               const emitHandler = (command) => {
                 if (cancelled)
                   return;
-                emitQueue.enqueue(command);
-                processEmitQueue().catch((err) => {
-                  if (!cancelled) {
-                    observer.next?.({ error: err instanceof Error ? err : new Error(String(err)) });
-                  }
-                });
+                const ops = toOps(command);
+                observer.next?.({ $: "ops", ops });
               };
               const isArrayOutput = Array.isArray(def._output);
               const emit = createEmit(emitHandler, isArrayOutput);
@@ -620,16 +570,16 @@ class LensServerImpl {
                     cleanups.splice(idx, 1);
                 };
               };
-              const createFieldEmit = isQuery ? this.createFieldEmitFactory(() => currentState, (state) => {
-                currentState = state;
-              }, emitIfChanged, select, context, onCleanup) : undefined;
+              const createFieldEmit = isQuery ? this.createFieldEmitFactory((command) => {
+                const ops = toOps(command);
+                observer.next?.({ $: "ops", ops });
+              }) : undefined;
               const lensContext = { ...context, emit, onCleanup };
               const result = resolver({ args: cleanInput, 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);
                 }
@@ -638,7 +588,6 @@ class LensServerImpl {
                 }
               } else {
                 const value = await result;
-                currentState = value;
                 const processed = isQuery ? await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit) : value;
                 emitIfChanged(processed);
                 if (isQuery && isLiveQueryDef(def) && !cancelled) {
@@ -655,8 +604,11 @@ class LensServerImpl {
                       }
                     } catch (err) {
                       if (!cancelled) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
                         observer.next?.({
-                          error: err instanceof Error ? err : new Error(String(err))
+                          $: "error",
+                          error: errMsg,
+                          code: "SUBSCRIBE_ERROR"
                         });
                       }
                     }
@@ -669,7 +621,8 @@ class LensServerImpl {
             });
           } catch (error) {
             if (!cancelled) {
-              observer.next?.({ error: error instanceof Error ? error : new Error(String(error)) });
+              const errMsg = error instanceof Error ? error.message : String(error);
+              observer.next?.({ $: "error", error: errMsg, code: "INTERNAL_ERROR" });
               observer.complete?.();
             }
           } finally {
@@ -687,128 +640,54 @@ class LensServerImpl {
       }
     };
   }
-  applyEmitCommand(command, state) {
-    switch (command.type) {
-      case "full":
-        if (command.replace) {
-          return command.data;
-        }
-        if (state && typeof state === "object" && typeof command.data === "object") {
-          return { ...state, ...command.data };
-        }
-        return command.data;
-      case "field": {
-        if (command.field === "") {
-          return applyUpdate(state, command.update);
-        }
-        if (state && typeof state === "object") {
-          const currentValue = state[command.field];
-          const newValue = applyUpdate(currentValue, command.update);
-          return {
-            ...state,
-            [command.field]: newValue
-          };
-        }
-        return { [command.field]: applyUpdate(undefined, command.update) };
-      }
-      case "batch":
-        if (state && typeof state === "object") {
-          const result = { ...state };
-          for (const update of command.updates) {
-            const currentValue = result[update.field];
-            result[update.field] = applyUpdate(currentValue, update.update);
-          }
-          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;
-    }
-  }
-  createFieldEmitFactory(getCurrentState, setCurrentState, notifyObserver, select, context, onCleanup) {
+  createFieldEmitFactory(sendUpdate) {
     return (fieldPath, resolvedValue) => {
       if (!fieldPath)
         return;
-      const state = getCurrentState();
-      const currentFieldValue = resolvedValue !== undefined ? resolvedValue : state ? this.getFieldByPath(state, fieldPath) : undefined;
       let outputType = "object";
-      if (Array.isArray(currentFieldValue)) {
+      if (Array.isArray(resolvedValue)) {
         outputType = "array";
-      } else if (currentFieldValue === null || typeof currentFieldValue === "string" || typeof currentFieldValue === "number" || typeof currentFieldValue === "boolean") {
+      } else if (resolvedValue === null || typeof resolvedValue === "string" || typeof resolvedValue === "number" || typeof resolvedValue === "boolean") {
         outputType = "scalar";
       }
-      let localFieldValue = resolvedValue;
       const emitHandler = (command) => {
-        const fullState = getCurrentState();
-        if (!fullState || typeof fullState !== "object")
-          return;
-        const stateFieldValue = this.getFieldByPath(fullState, fieldPath);
-        const fieldValue = stateFieldValue !== undefined ? stateFieldValue : localFieldValue;
-        const newFieldValue = this.applyEmitCommand(command, fieldValue);
-        localFieldValue = newFieldValue;
-        const updatedState = this.setFieldByPath(fullState, fieldPath, newFieldValue);
-        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);
-          }
-        })();
+        const prefixedCommand = this.prefixCommandPath(command, fieldPath);
+        sendUpdate(prefixedCommand);
       };
       return createEmit(emitHandler, outputType);
     };
   }
-  getFieldByPath(obj, path) {
-    if (!obj || typeof obj !== "object")
-      return;
-    const parts = path.split(".");
-    let current = obj;
-    for (const part of parts) {
-      if (!current || typeof current !== "object")
-        return;
-      current = current[part];
-    }
-    return current;
-  }
-  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)
-      };
+  prefixCommandPath(command, prefix) {
+    switch (command.type) {
+      case "full":
+        return {
+          type: "field",
+          field: prefix,
+          update: { strategy: "value", data: command.data }
+        };
+      case "field":
+        return {
+          type: "field",
+          field: command.field ? `${prefix}.${command.field}` : prefix,
+          update: command.update
+        };
+      case "batch":
+        return {
+          type: "batch",
+          updates: command.updates.map((u) => ({
+            field: `${prefix}.${u.field}`,
+            update: u.update
+          }))
+        };
+      case "array":
+        return {
+          type: "array",
+          operation: command.operation,
+          field: prefix
+        };
+      default:
+        return command;
     }
-    return obj;
   }
   async processQueryResult(_operationName, data, select, context, onCleanup, createFieldEmit) {
     if (!data)
@@ -1199,7 +1078,7 @@ function createSSEHandler(config = {}) {
 }
 
 // src/handlers/http.ts
-import { firstValueFrom } from "@sylphx/lens-core";
+import { firstValueFrom, isError, isSnapshot } from "@sylphx/lens-core";
 function sanitizeError(error, isDevelopment) {
   if (isDevelopment) {
     return error.message;
@@ -1340,8 +1219,8 @@ function createHTTPHandler(server, options = {}) {
           path: operationPath2,
           input: body.input
         }));
-        if (result2.error) {
-          return new Response(JSON.stringify({ error: sanitize(result2.error) }), {
+        if (isError(result2)) {
+          return new Response(JSON.stringify({ error: result2.error }), {
             status: 500,
             headers: {
               "Content-Type": "application/json",
@@ -1349,7 +1228,15 @@ function createHTTPHandler(server, options = {}) {
             }
           });
         }
-        return new Response(JSON.stringify({ data: result2.data }), {
+        if (isSnapshot(result2)) {
+          return new Response(JSON.stringify({ data: result2.data }), {
+            headers: {
+              "Content-Type": "application/json",
+              ...baseHeaders
+            }
+          });
+        }
+        return new Response(JSON.stringify(result2), {
           headers: {
             "Content-Type": "application/json",
             ...baseHeaders
@@ -1408,7 +1295,7 @@ function createHandler(server, options = {}) {
   return result;
 }
 // src/handlers/framework.ts
-import { firstValueFrom as firstValueFrom2 } from "@sylphx/lens-core";
+import { firstValueFrom as firstValueFrom2, isError as isError2, isSnapshot as isSnapshot2 } from "@sylphx/lens-core";
 function createServerClientProxy(server) {
   function createProxy(path) {
     return new Proxy(() => {}, {
@@ -1423,10 +1310,13 @@ function createServerClientProxy(server) {
       async apply(_, __, args) {
         const input = args[0];
         const result = await firstValueFrom2(server.execute({ path, input }));
-        if (result.error) {
-          throw result.error;
+        if (isError2(result)) {
+          throw new Error(result.error);
+        }
+        if (isSnapshot2(result)) {
+          return result.data;
         }
-        return result.data;
+        return null;
       }
     });
   }
@@ -1437,10 +1327,13 @@ async function handleWebQuery(server, path, url) {
     const inputParam = url.searchParams.get("input");
     const input = inputParam ? JSON.parse(inputParam) : undefined;
     const result = await firstValueFrom2(server.execute({ path, input }));
-    if (result.error) {
-      return Response.json({ error: result.error.message }, { status: 400 });
+    if (isError2(result)) {
+      return Response.json({ error: result.error }, { status: 400 });
     }
-    return Response.json({ data: result.data });
+    if (isSnapshot2(result)) {
+      return Response.json({ data: result.data });
+    }
+    return Response.json(result);
   } catch (error) {
     return Response.json({ error: error instanceof Error ? error.message : "Unknown error" }, { status: 500 });
   }
@@ -1450,10 +1343,13 @@ async function handleWebMutation(server, path, request) {
     const body = await request.json();
     const input = body.input;
     const result = await firstValueFrom2(server.execute({ path, input }));
-    if (result.error) {
-      return Response.json({ error: result.error.message }, { status: 400 });
+    if (isError2(result)) {
+      return Response.json({ error: result.error }, { status: 400 });
+    }
+    if (isSnapshot2(result)) {
+      return Response.json({ data: result.data });
     }
-    return Response.json({ data: result.data });
+    return Response.json(result);
   } catch (error) {
     return Response.json({ error: error instanceof Error ? error.message : "Unknown error" }, { status: 500 });
   }
@@ -1522,7 +1418,9 @@ function createFrameworkHandler(server, options = {}) {
 }
 // src/handlers/ws.ts
 import {
-  firstValueFrom as firstValueFrom3
+  firstValueFrom as firstValueFrom3,
+  isError as isError3,
+  isSnapshot as isSnapshot3
 } from "@sylphx/lens-core";
 function createWSHandler(server, options = {}) {
   const { logger = {} } = options;
@@ -1660,17 +1558,20 @@ function createWSHandler(server, options = {}) {
       }));
       return;
     }
-    let result;
+    let resultData;
     try {
-      result = await firstValueFrom3(server.execute({ path: operation, input }));
-      if (result.error) {
+      const result = await firstValueFrom3(server.execute({ path: operation, input }));
+      if (isError3(result)) {
         conn.ws.send(JSON.stringify({
           type: "error",
           id,
-          error: { code: "EXECUTION_ERROR", message: result.error.message }
+          error: { code: "EXECUTION_ERROR", message: result.error }
         }));
         return;
       }
+      if (isSnapshot3(result)) {
+        resultData = result.data;
+      }
     } catch (error) {
       conn.ws.send(JSON.stringify({
         type: "error",
@@ -1679,7 +1580,7 @@ function createWSHandler(server, options = {}) {
       }));
       return;
     }
-    const entities = result.data ? extractEntities(result.data) : [];
+    const entities = resultData ? extractEntities(resultData) : [];
     const existingSub = conn.subscriptions.get(id);
     if (existingSub) {
       for (const cleanup of existingSub.cleanups) {
@@ -1704,7 +1605,7 @@ function createWSHandler(server, options = {}) {
       fields,
       entityKeys: new Set(entities.map(({ entity, entityId }) => `${entity}:${entityId}`)),
       cleanups: [],
-      lastData: result.data
+      lastData: resultData
     };
     for (const { entity, entityId, entityData } of entities) {
       const allowed = await server.subscribe({
@@ -1792,20 +1693,22 @@ function createWSHandler(server, options = {}) {
         path: message.operation,
         input: message.input
       }));
-      if (result.error) {
+      if (isError3(result)) {
         conn.ws.send(JSON.stringify({
           type: "error",
           id: message.id,
-          error: { code: "EXECUTION_ERROR", message: result.error.message }
+          error: { code: "EXECUTION_ERROR", message: result.error }
         }));
         return;
       }
-      const selected = message.fields ? applySelection2(result.data, message.fields) : result.data;
-      conn.ws.send(JSON.stringify({
-        type: "result",
-        id: message.id,
-        data: selected
-      }));
+      if (isSnapshot3(result)) {
+        const selected = message.fields ? applySelection2(result.data, message.fields) : result.data;
+        conn.ws.send(JSON.stringify({
+          type: "result",
+          id: message.id,
+          data: selected
+        }));
+      }
     } catch (error) {
       conn.ws.send(JSON.stringify({
         type: "error",
@@ -1820,25 +1723,25 @@ function createWSHandler(server, options = {}) {
         path: message.operation,
         input: message.input
       }));
-      if (result.error) {
+      if (isError3(result)) {
         conn.ws.send(JSON.stringify({
           type: "error",
           id: message.id,
-          error: { code: "EXECUTION_ERROR", message: result.error.message }
+          error: { code: "EXECUTION_ERROR", message: result.error }
         }));
         return;
       }
-      if (result.data) {
+      if (isSnapshot3(result)) {
         const entities = extractEntities(result.data);
         for (const { entity, entityId, entityData } of entities) {
           await server.broadcast(entity, entityId, entityData);
         }
+        conn.ws.send(JSON.stringify({
+          type: "result",
+          id: message.id,
+          data: result.data
+        }));
       }
-      conn.ws.send(JSON.stringify({
-        type: "result",
-        id: message.id,
-        data: result.data
-      }));
     } catch (error) {
       conn.ws.send(JSON.stringify({
         type: "error",

package/package.json

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