@sylphx/lens-server 1.0.3 → 1.2.0

package/dist/index.js

@@ -1,286 +1,28 @@
-// ../core/dist/index.js
-import { AsyncLocalStorage } from "node:async_hooks";
-var ENTITY_SYMBOL = Symbol("lens:entity");
-var valueStrategy = {
-  name: "value",
-  encode(_prev, next) {
-    return { strategy: "value", data: next };
-  },
-  decode(_current, update) {
-    return update.data;
-  },
-  estimateSize(update) {
-    return JSON.stringify(update.data).length;
-  }
-};
-var deltaStrategy = {
-  name: "delta",
-  encode(prev, next) {
-    const operations = computeStringDiff(prev, next);
-    const diffSize = JSON.stringify(operations).length;
-    const valueSize = next.length + 20;
-    if (diffSize >= valueSize) {
-      return { strategy: "value", data: next };
-    }
-    return { strategy: "delta", data: operations };
-  },
-  decode(current, update) {
-    if (update.strategy === "value") {
-      return update.data;
-    }
-    const operations = update.data;
-    return applyStringDiff(current, operations);
-  },
-  estimateSize(update) {
-    return JSON.stringify(update.data).length;
-  }
-};
-function computeStringDiff(prev, next) {
-  const operations = [];
-  let prefixLen = 0;
-  const minLen = Math.min(prev.length, next.length);
-  while (prefixLen < minLen && prev[prefixLen] === next[prefixLen]) {
-    prefixLen++;
-  }
-  let suffixLen = 0;
-  const remainingPrev = prev.length - prefixLen;
-  const remainingNext = next.length - prefixLen;
-  const maxSuffix = Math.min(remainingPrev, remainingNext);
-  while (suffixLen < maxSuffix && prev[prev.length - 1 - suffixLen] === next[next.length - 1 - suffixLen]) {
-    suffixLen++;
-  }
-  const deleteCount = prev.length - prefixLen - suffixLen;
-  const insertText = next.slice(prefixLen, next.length - suffixLen || undefined);
-  if (deleteCount > 0 || insertText.length > 0) {
-    operations.push({
-      position: prefixLen,
-      ...deleteCount > 0 ? { delete: deleteCount } : {},
-      ...insertText.length > 0 ? { insert: insertText } : {}
-    });
-  }
-  return operations;
-}
-function applyStringDiff(current, operations) {
-  let result = current;
-  const sortedOps = [...operations].sort((a, b) => b.position - a.position);
-  for (const op of sortedOps) {
-    const before = result.slice(0, op.position);
-    const after = result.slice(op.position + (op.delete ?? 0));
-    result = before + (op.insert ?? "") + after;
-  }
-  return result;
-}
-var patchStrategy = {
-  name: "patch",
-  encode(prev, next) {
-    const operations = computeJsonPatch(prev, next);
-    const patchSize = JSON.stringify(operations).length;
-    const valueSize = JSON.stringify(next).length + 20;
-    if (patchSize >= valueSize) {
-      return { strategy: "value", data: next };
-    }
-    return { strategy: "patch", data: operations };
-  },
-  decode(current, update) {
-    if (update.strategy === "value") {
-      return update.data;
-    }
-    const operations = update.data;
-    return applyJsonPatch(current, operations);
-  },
-  estimateSize(update) {
-    return JSON.stringify(update.data).length;
-  }
-};
-function computeJsonPatch(prev, next, basePath = "") {
-  const operations = [];
-  const prevObj = prev;
-  const nextObj = next;
-  for (const key of Object.keys(prevObj)) {
-    if (!(key in nextObj)) {
-      operations.push({ op: "remove", path: `${basePath}/${escapeJsonPointer(key)}` });
-    }
-  }
-  for (const [key, nextValue] of Object.entries(nextObj)) {
-    const path = `${basePath}/${escapeJsonPointer(key)}`;
-    const prevValue = prevObj[key];
-    if (!(key in prevObj)) {
-      operations.push({ op: "add", path, value: nextValue });
-    } else if (!deepEqual(prevValue, nextValue)) {
-      if (isPlainObject(prevValue) && isPlainObject(nextValue) && !Array.isArray(prevValue) && !Array.isArray(nextValue)) {
-        operations.push(...computeJsonPatch(prevValue, nextValue, path));
-      } else {
-        operations.push({ op: "replace", path, value: nextValue });
-      }
-    }
-  }
-  return operations;
-}
-function applyJsonPatch(current, operations) {
-  const result = structuredClone(current);
-  for (const op of operations) {
-    const pathParts = parseJsonPointer(op.path);
-    switch (op.op) {
-      case "add":
-      case "replace":
-        setValueAtPath(result, pathParts, op.value);
-        break;
-      case "remove":
-        removeValueAtPath(result, pathParts);
-        break;
-      case "move":
-        if (op.from) {
-          const fromParts = parseJsonPointer(op.from);
-          const value = getValueAtPath(result, fromParts);
-          removeValueAtPath(result, fromParts);
-          setValueAtPath(result, pathParts, value);
-        }
-        break;
-      case "copy":
-        if (op.from) {
-          const fromParts = parseJsonPointer(op.from);
-          const value = structuredClone(getValueAtPath(result, fromParts));
-          setValueAtPath(result, pathParts, value);
-        }
-        break;
-      case "test":
-        break;
-    }
-  }
-  return result;
-}
-var THRESHOLDS = {
-  STRING_DELTA_MIN: 100,
-  OBJECT_PATCH_MIN: 50
-};
-function selectStrategy(prev, next) {
-  if (typeof prev === "string" && typeof next === "string") {
-    if (next.length >= THRESHOLDS.STRING_DELTA_MIN) {
-      return deltaStrategy;
-    }
-    return valueStrategy;
-  }
-  if (typeof next !== "object" || next === null) {
-    return valueStrategy;
-  }
-  if (isPlainObject(prev) && isPlainObject(next)) {
-    const prevSize = JSON.stringify(prev).length;
-    if (prevSize >= THRESHOLDS.OBJECT_PATCH_MIN) {
-      return patchStrategy;
-    }
-  }
-  return valueStrategy;
-}
-function createUpdate(prev, next) {
-  const strategy = selectStrategy(prev, next);
-  return strategy.encode(prev, next);
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function deepEqual(a, b) {
-  if (a === b)
-    return true;
-  if (typeof a !== typeof b)
-    return false;
-  if (typeof a !== "object" || a === null || b === null)
-    return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length)
-    return false;
-  for (const key of aKeys) {
-    if (!deepEqual(a[key], b[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-function escapeJsonPointer(str) {
-  return str.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-function parseJsonPointer(path) {
-  if (!path || path === "/")
-    return [];
-  return path.slice(1).split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
-}
-function getValueAtPath(obj, path) {
-  let current = obj;
-  for (const key of path) {
-    if (current === null || typeof current !== "object")
-      return;
-    current = current[key];
-  }
-  return current;
-}
-function setValueAtPath(obj, path, value) {
-  if (path.length === 0)
-    return;
-  let current = obj;
-  for (let i = 0;i < path.length - 1; i++) {
-    const key = path[i];
-    if (!(key in current) || typeof current[key] !== "object") {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-  current[path[path.length - 1]] = value;
-}
-function removeValueAtPath(obj, path) {
-  if (path.length === 0)
-    return;
-  let current = obj;
-  for (let i = 0;i < path.length - 1; i++) {
-    const key = path[i];
-    if (!(key in current) || typeof current[key] !== "object")
-      return;
-    current = current[key];
-  }
-  delete current[path[path.length - 1]];
-}
-function isQueryDef(value) {
-  return typeof value === "object" && value !== null && value._type === "query";
-}
-function isMutationDef(value) {
-  return typeof value === "object" && value !== null && value._type === "mutation";
-}
-function isRouterDef(value) {
-  return typeof value === "object" && value !== null && value._type === "router";
-}
-function flattenRouter(routerDef, prefix = "") {
-  const result = new Map;
-  for (const [key, value] of Object.entries(routerDef._routes)) {
-    const path = prefix ? `${prefix}.${key}` : key;
-    if (isRouterDef(value)) {
-      const nested = flattenRouter(value, path);
-      for (const [nestedPath, procedure] of nested) {
-        result.set(nestedPath, procedure);
-      }
-    } else {
-      result.set(path, value);
-    }
-  }
-  return result;
-}
-function isBatchResolver(resolver) {
-  return typeof resolver === "object" && resolver !== null && "batch" in resolver;
-}
-var globalContextStore = new AsyncLocalStorage;
-function createContext() {
-  return globalContextStore;
-}
-function runWithContext(_context, value, fn) {
-  return globalContextStore.run(value, fn);
-}
-function makeEntityKey(entity2, id) {
-  return `${entity2}:${id}`;
-}
+// src/server/create.ts
+import {
+  createContext,
+  createEmit,
+  createUpdate as createUpdate2,
+  flattenRouter,
+  isBatchResolver,
+  isMutationDef,
+  isQueryDef,
+  runWithContext
+} from "@sylphx/lens-core";
 
 // src/state/graph-state-manager.ts
+import {
+  createUpdate,
+  applyUpdate,
+  makeEntityKey
+} from "@sylphx/lens-core";
+
 class GraphStateManager {
   clients = new Map;
   canonical = new Map;
+  canonicalArrays = new Map;
   clientStates = new Map;
+  clientArrayStates = new Map;
   entitySubscribers = new Map;
   config;
   constructor(config = {}) {
@@ -289,6 +31,7 @@ class GraphStateManager {
   addClient(client) {
     this.clients.set(client.id, client);
     this.clientStates.set(client.id, new Map);
+    this.clientArrayStates.set(client.id, new Map);
   }
   removeClient(clientId) {
     for (const [key, subscribers] of this.entitySubscribers) {
@@ -299,6 +42,7 @@ class GraphStateManager {
     }
     this.clients.delete(clientId);
     this.clientStates.delete(clientId);
+    this.clientArrayStates.delete(clientId);
   }
   subscribe(clientId, entity, id, fields = "*") {
     const key = this.makeKey(entity, id);
@@ -361,6 +105,148 @@ class GraphStateManager {
       this.pushToClient(clientId, entity, id, key, currentCanonical);
     }
   }
+  emitField(entity, id, field, update) {
+    const key = this.makeKey(entity, id);
+    let currentCanonical = this.canonical.get(key);
+    if (!currentCanonical) {
+      currentCanonical = {};
+    }
+    const oldValue = currentCanonical[field];
+    const newValue = applyUpdate(oldValue, update);
+    currentCanonical = { ...currentCanonical, [field]: newValue };
+    this.canonical.set(key, currentCanonical);
+    const subscribers = this.entitySubscribers.get(key);
+    if (!subscribers)
+      return;
+    for (const clientId of subscribers) {
+      this.pushFieldToClient(clientId, entity, id, key, field, newValue);
+    }
+  }
+  emitBatch(entity, id, updates) {
+    const key = this.makeKey(entity, id);
+    let currentCanonical = this.canonical.get(key);
+    if (!currentCanonical) {
+      currentCanonical = {};
+    }
+    const changedFields = [];
+    for (const { field, update } of updates) {
+      const oldValue = currentCanonical[field];
+      const newValue = applyUpdate(oldValue, update);
+      currentCanonical[field] = newValue;
+      changedFields.push(field);
+    }
+    this.canonical.set(key, currentCanonical);
+    const subscribers = this.entitySubscribers.get(key);
+    if (!subscribers)
+      return;
+    for (const clientId of subscribers) {
+      this.pushFieldsToClient(clientId, entity, id, key, changedFields, currentCanonical);
+    }
+  }
+  processCommand(entity, id, command) {
+    switch (command.type) {
+      case "full":
+        this.emit(entity, id, command.data, {
+          replace: command.replace
+        });
+        break;
+      case "field":
+        this.emitField(entity, id, command.field, command.update);
+        break;
+      case "batch":
+        this.emitBatch(entity, id, command.updates);
+        break;
+      case "array":
+        this.emitArrayOperation(entity, id, command.operation);
+        break;
+    }
+  }
+  emitArray(entity, id, items) {
+    const key = this.makeKey(entity, id);
+    this.canonicalArrays.set(key, [...items]);
+    const subscribers = this.entitySubscribers.get(key);
+    if (!subscribers)
+      return;
+    for (const clientId of subscribers) {
+      this.pushArrayToClient(clientId, entity, id, key, items);
+    }
+  }
+  emitArrayOperation(entity, id, operation) {
+    const key = this.makeKey(entity, id);
+    let currentArray = this.canonicalArrays.get(key);
+    if (!currentArray) {
+      currentArray = [];
+    }
+    const newArray = this.applyArrayOperation([...currentArray], operation);
+    this.canonicalArrays.set(key, newArray);
+    const subscribers = this.entitySubscribers.get(key);
+    if (!subscribers)
+      return;
+    for (const clientId of subscribers) {
+      this.pushArrayToClient(clientId, entity, id, key, newArray);
+    }
+  }
+  applyArrayOperation(array, operation) {
+    switch (operation.op) {
+      case "push":
+        return [...array, operation.item];
+      case "unshift":
+        return [operation.item, ...array];
+      case "insert":
+        return [
+          ...array.slice(0, operation.index),
+          operation.item,
+          ...array.slice(operation.index)
+        ];
+      case "remove":
+        return [...array.slice(0, operation.index), ...array.slice(operation.index + 1)];
+      case "removeById": {
+        const idx = array.findIndex((item) => typeof item === "object" && item !== null && ("id" in item) && item.id === operation.id);
+        if (idx === -1)
+          return array;
+        return [...array.slice(0, idx), ...array.slice(idx + 1)];
+      }
+      case "update":
+        return array.map((item, i) => i === operation.index ? operation.item : item);
+      case "updateById":
+        return array.map((item) => typeof item === "object" && item !== null && ("id" in item) && item.id === operation.id ? operation.item : item);
+      case "merge":
+        return array.map((item, i) => i === operation.index && typeof item === "object" && item !== null ? { ...item, ...operation.partial } : item);
+      case "mergeById":
+        return array.map((item) => typeof item === "object" && item !== null && ("id" in item) && item.id === operation.id ? { ...item, ...operation.partial } : item);
+      default:
+        return array;
+    }
+  }
+  pushArrayToClient(clientId, entity, id, key, newArray) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return;
+    const clientArrayStateMap = this.clientArrayStates.get(clientId);
+    if (!clientArrayStateMap)
+      return;
+    let clientArrayState = clientArrayStateMap.get(key);
+    if (!clientArrayState) {
+      clientArrayState = { lastState: [] };
+      clientArrayStateMap.set(key, clientArrayState);
+    }
+    const { lastState } = clientArrayState;
+    if (JSON.stringify(lastState) === JSON.stringify(newArray)) {
+      return;
+    }
+    client.send({
+      type: "update",
+      entity,
+      id,
+      updates: {
+        _items: { strategy: "value", data: newArray }
+      }
+    });
+    clientArrayState.lastState = [...newArray];
+  }
+  getArrayState(entity, id) {
+    return this.canonicalArrays.get(this.makeKey(entity, id));
+  }
   getState(entity, id) {
     return this.canonical.get(this.makeKey(entity, id));
   }
@@ -408,6 +294,77 @@ class GraphStateManager {
       }
     }
   }
+  pushFieldToClient(clientId, entity, id, key, field, newValue) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return;
+    const clientStateMap = this.clientStates.get(clientId);
+    if (!clientStateMap)
+      return;
+    const clientEntityState = clientStateMap.get(key);
+    if (!clientEntityState)
+      return;
+    const { lastState, fields } = clientEntityState;
+    if (fields !== "*" && !fields.has(field)) {
+      return;
+    }
+    const oldValue = lastState[field];
+    if (oldValue === newValue)
+      return;
+    if (typeof oldValue === "object" && typeof newValue === "object" && JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+      return;
+    }
+    const update = createUpdate(oldValue, newValue);
+    client.send({
+      type: "update",
+      entity,
+      id,
+      updates: { [field]: update }
+    });
+    clientEntityState.lastState[field] = newValue;
+  }
+  pushFieldsToClient(clientId, entity, id, key, changedFields, newState) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return;
+    const clientStateMap = this.clientStates.get(clientId);
+    if (!clientStateMap)
+      return;
+    const clientEntityState = clientStateMap.get(key);
+    if (!clientEntityState)
+      return;
+    const { lastState, fields } = clientEntityState;
+    const updates = {};
+    let hasChanges = false;
+    for (const field of changedFields) {
+      if (fields !== "*" && !fields.has(field)) {
+        continue;
+      }
+      const oldValue = lastState[field];
+      const newValue = newState[field];
+      if (oldValue === newValue)
+        continue;
+      if (typeof oldValue === "object" && typeof newValue === "object" && JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+        continue;
+      }
+      const update = createUpdate(oldValue, newValue);
+      updates[field] = update;
+      hasChanges = true;
+    }
+    if (!hasChanges)
+      return;
+    client.send({
+      type: "update",
+      entity,
+      id,
+      updates
+    });
+    for (const field of changedFields) {
+      if (newState[field] !== undefined) {
+        clientEntityState.lastState[field] = newState[field];
+      }
+    }
+  }
   sendInitialData(clientId, entity, id, state, fields) {
     const client = this.clients.get(clientId);
     if (!client)
@@ -460,7 +417,9 @@ class GraphStateManager {
   clear() {
     this.clients.clear();
     this.canonical.clear();
+    this.canonicalArrays.clear();
     this.clientStates.clear();
+    this.clientArrayStates.clear();
     this.entitySubscribers.clear();
   }
 }
@@ -770,21 +729,31 @@ class LensServerImpl {
       if (!resolver) {
         throw new Error(`Query ${sub.operation} has no resolver`);
       }
-      const contextWithHelpers = {
-        ...context,
-        emit: emitData,
-        onCleanup: (fn) => {
-          sub.cleanups.push(fn);
-          return () => {
-            const idx = sub.cleanups.indexOf(fn);
-            if (idx >= 0)
-              sub.cleanups.splice(idx, 1);
-          };
+      const emit = createEmit((command) => {
+        const entityName = this.getEntityNameFromOutput(queryDef._output);
+        if (entityName) {
+          const entities = this.extractEntities(entityName, command.type === "full" ? command.data : {});
+          for (const { entity, id } of entities) {
+            this.stateManager.processCommand(entity, id, command);
+          }
         }
+        if (command.type === "full") {
+          emitData(command.data);
+        }
+      });
+      const onCleanup = (fn) => {
+        sub.cleanups.push(fn);
+        return () => {
+          const idx = sub.cleanups.indexOf(fn);
+          if (idx >= 0)
+            sub.cleanups.splice(idx, 1);
+        };
       };
       const result = resolver({
         input: sub.input,
-        ctx: contextWithHelpers
+        ctx: context,
+        emit,
+        onCleanup
       });
       if (isAsyncIterable(result)) {
         for await (const value of result) {
@@ -933,13 +902,14 @@ class LensServerImpl {
         if (!resolver) {
           throw new Error(`Query ${name} has no resolver`);
         }
-        const resolverCtx = {
+        const emit = createEmit(() => {});
+        const onCleanup = () => () => {};
+        const result = resolver({
           input: cleanInput,
           ctx: context,
-          emit: () => {},
-          onCleanup: () => () => {}
-        };
-        const result = resolver(resolverCtx);
+          emit,
+          onCleanup
+        });
         let data;
         if (isAsyncIterable(result)) {
           for await (const value of result) {
@@ -976,9 +946,13 @@ class LensServerImpl {
         if (!resolver) {
           throw new Error(`Mutation ${name} has no resolver`);
         }
+        const emit = createEmit(() => {});
+        const onCleanup = () => () => {};
         const result = await resolver({
           input,
-          ctx: context
+          ctx: context,
+          emit,
+          onCleanup
         });
         const entityName = this.getEntityNameFromMutation(name);
         const entities = this.extractEntities(entityName, result);
@@ -1301,7 +1275,7 @@ class LensServerImpl {
       const oldValue = oldObj[key];
       const newValue = newObj[key];
       if (!this.deepEqual(oldValue, newValue)) {
-        updates[key] = createUpdate(oldValue, newValue);
+        updates[key] = createUpdate2(oldValue, newValue);
       }
     }
     return Object.keys(updates).length > 0 ? updates : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylphx/lens-server",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "Server runtime for Lens API framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,8 +12,7 @@
     }
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node && bun run build:types",
-    "build:types": "tsc --emitDeclarationOnly --outDir ./dist",
+    "build": "bunup",
     "typecheck": "tsc --noEmit",
     "test": "bun test"
   },
@@ -30,7 +29,7 @@
   "author": "SylphxAI",
   "license": "MIT",
   "dependencies": {
-    "@sylphx/lens-core": "^1.0.3"
+    "@sylphx/lens-core": "^1.2.0"
   },
   "devDependencies": {
     "typescript": "^5.9.3",