@sylphx/lens-server 1.0.2

package/dist/index.js

@@ -0,0 +1,1437 @@
+// ../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/state/graph-state-manager.ts
+class GraphStateManager {
+  clients = new Map;
+  canonical = new Map;
+  clientStates = new Map;
+  entitySubscribers = new Map;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  addClient(client) {
+    this.clients.set(client.id, client);
+    this.clientStates.set(client.id, new Map);
+  }
+  removeClient(clientId) {
+    for (const [key, subscribers] of this.entitySubscribers) {
+      subscribers.delete(clientId);
+      if (subscribers.size === 0) {
+        this.cleanupEntity(key);
+      }
+    }
+    this.clients.delete(clientId);
+    this.clientStates.delete(clientId);
+  }
+  subscribe(clientId, entity, id, fields = "*") {
+    const key = this.makeKey(entity, id);
+    let subscribers = this.entitySubscribers.get(key);
+    if (!subscribers) {
+      subscribers = new Set;
+      this.entitySubscribers.set(key, subscribers);
+    }
+    subscribers.add(clientId);
+    const clientStateMap = this.clientStates.get(clientId);
+    if (clientStateMap) {
+      const fieldSet = fields === "*" ? "*" : new Set(fields);
+      clientStateMap.set(key, {
+        lastState: {},
+        fields: fieldSet
+      });
+    }
+    const canonicalState = this.canonical.get(key);
+    if (canonicalState) {
+      this.sendInitialData(clientId, entity, id, canonicalState, fields);
+    }
+  }
+  unsubscribe(clientId, entity, id) {
+    const key = this.makeKey(entity, id);
+    const subscribers = this.entitySubscribers.get(key);
+    if (subscribers) {
+      subscribers.delete(clientId);
+      if (subscribers.size === 0) {
+        this.cleanupEntity(key);
+      }
+    }
+    const clientStateMap = this.clientStates.get(clientId);
+    if (clientStateMap) {
+      clientStateMap.delete(key);
+    }
+  }
+  updateSubscription(clientId, entity, id, fields) {
+    const key = this.makeKey(entity, id);
+    const clientStateMap = this.clientStates.get(clientId);
+    if (clientStateMap) {
+      const state = clientStateMap.get(key);
+      if (state) {
+        state.fields = fields === "*" ? "*" : new Set(fields);
+      }
+    }
+  }
+  emit(entity, id, data, options = {}) {
+    const key = this.makeKey(entity, id);
+    let currentCanonical = this.canonical.get(key);
+    if (options.replace || !currentCanonical) {
+      currentCanonical = { ...data };
+    } else {
+      currentCanonical = { ...currentCanonical, ...data };
+    }
+    this.canonical.set(key, currentCanonical);
+    const subscribers = this.entitySubscribers.get(key);
+    if (!subscribers)
+      return;
+    for (const clientId of subscribers) {
+      this.pushToClient(clientId, entity, id, key, currentCanonical);
+    }
+  }
+  getState(entity, id) {
+    return this.canonical.get(this.makeKey(entity, id));
+  }
+  hasSubscribers(entity, id) {
+    const subscribers = this.entitySubscribers.get(this.makeKey(entity, id));
+    return subscribers !== undefined && subscribers.size > 0;
+  }
+  pushToClient(clientId, entity, id, key, 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 fieldsToCheck = fields === "*" ? Object.keys(newState) : Array.from(fields);
+    const updates = {};
+    let hasChanges = false;
+    for (const field of fieldsToCheck) {
+      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 fieldsToCheck) {
+      if (newState[field] !== undefined) {
+        clientEntityState.lastState[field] = newState[field];
+      }
+    }
+  }
+  sendInitialData(clientId, entity, id, state, fields) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return;
+    const key = this.makeKey(entity, id);
+    const clientStateMap = this.clientStates.get(clientId);
+    if (!clientStateMap)
+      return;
+    const fieldsToSend = fields === "*" ? Object.keys(state) : fields;
+    const dataToSend = {};
+    const updates = {};
+    for (const field of fieldsToSend) {
+      if (state[field] !== undefined) {
+        dataToSend[field] = state[field];
+        updates[field] = { strategy: "value", data: state[field] };
+      }
+    }
+    client.send({
+      type: "update",
+      entity,
+      id,
+      updates
+    });
+    const clientEntityState = clientStateMap.get(key);
+    if (clientEntityState) {
+      clientEntityState.lastState = { ...dataToSend };
+    }
+  }
+  cleanupEntity(key) {
+    const [entity, id] = key.split(":");
+    if (this.config.onEntityUnsubscribed) {
+      this.config.onEntityUnsubscribed(entity, id);
+    }
+    this.entitySubscribers.delete(key);
+  }
+  makeKey(entity, id) {
+    return makeEntityKey(entity, id);
+  }
+  getStats() {
+    let totalSubscriptions = 0;
+    for (const subscribers of this.entitySubscribers.values()) {
+      totalSubscriptions += subscribers.size;
+    }
+    return {
+      clients: this.clients.size,
+      entities: this.canonical.size,
+      totalSubscriptions
+    };
+  }
+  clear() {
+    this.clients.clear();
+    this.canonical.clear();
+    this.clientStates.clear();
+    this.entitySubscribers.clear();
+  }
+}
+function createGraphStateManager(config) {
+  return new GraphStateManager(config);
+}
+
+// src/server/create.ts
+class DataLoader {
+  batchFn;
+  batch = new Map;
+  scheduled = false;
+  constructor(batchFn) {
+    this.batchFn = batchFn;
+  }
+  async load(key) {
+    return new Promise((resolve, reject) => {
+      const existing = this.batch.get(key);
+      if (existing) {
+        existing.push({ resolve, reject });
+      } else {
+        this.batch.set(key, [{ resolve, reject }]);
+      }
+      this.scheduleDispatch();
+    });
+  }
+  scheduleDispatch() {
+    if (this.scheduled)
+      return;
+    this.scheduled = true;
+    queueMicrotask(() => this.dispatch());
+  }
+  async dispatch() {
+    this.scheduled = false;
+    const batch = this.batch;
+    this.batch = new Map;
+    const keys = Array.from(batch.keys());
+    if (keys.length === 0)
+      return;
+    try {
+      const results = await this.batchFn(keys);
+      keys.forEach((key, index) => {
+        const callbacks = batch.get(key);
+        const result = results[index] ?? null;
+        callbacks.forEach(({ resolve }) => resolve(result));
+      });
+    } catch (error) {
+      for (const callbacks of batch.values()) {
+        callbacks.forEach(({ reject }) => reject(error));
+      }
+    }
+  }
+  clear() {
+    this.batch.clear();
+  }
+}
+
+class LensServerImpl {
+  queries;
+  mutations;
+  entities;
+  resolvers;
+  contextFactory;
+  version;
+  ctx = createContext();
+  stateManager;
+  loaders = new Map;
+  connections = new Map;
+  connectionCounter = 0;
+  server = null;
+  constructor(config) {
+    const queries = { ...config.queries ?? {} };
+    const mutations = { ...config.mutations ?? {} };
+    if (config.router) {
+      const flattened = flattenRouter(config.router);
+      for (const [path, procedure] of flattened) {
+        if (isQueryDef(procedure)) {
+          queries[path] = procedure;
+        } else if (isMutationDef(procedure)) {
+          mutations[path] = procedure;
+        }
+      }
+    }
+    this.queries = queries;
+    this.mutations = mutations;
+    this.entities = config.entities ?? {};
+    this.resolvers = config.resolvers;
+    this.contextFactory = config.context ?? (() => ({}));
+    this.version = config.version ?? "1.0.0";
+    for (const [name, def] of Object.entries(this.entities)) {
+      if (def && typeof def === "object" && !def._name) {
+        def._name = name;
+      }
+    }
+    for (const [name, def] of Object.entries(this.mutations)) {
+      if (def && typeof def === "object") {
+        def._name = name;
+        const lastSegment = name.includes(".") ? name.split(".").pop() : name;
+        if (!def._optimistic) {
+          if (lastSegment.startsWith("update")) {
+            def._optimistic = "merge";
+          } else if (lastSegment.startsWith("create") || lastSegment.startsWith("add")) {
+            def._optimistic = "create";
+          } else if (lastSegment.startsWith("delete") || lastSegment.startsWith("remove")) {
+            def._optimistic = "delete";
+          }
+        }
+      }
+    }
+    for (const [name, def] of Object.entries(this.queries)) {
+      if (def && typeof def === "object") {
+        def._name = name;
+      }
+    }
+    this.stateManager = new GraphStateManager({
+      onEntityUnsubscribed: (_entity, _id) => {}
+    });
+    for (const [name, def] of Object.entries(this.queries)) {
+      if (!isQueryDef(def)) {
+        throw new Error(`Invalid query definition: ${name}`);
+      }
+    }
+    for (const [name, def] of Object.entries(this.mutations)) {
+      if (!isMutationDef(def)) {
+        throw new Error(`Invalid mutation definition: ${name}`);
+      }
+    }
+  }
+  getStateManager() {
+    return this.stateManager;
+  }
+  getMetadata() {
+    return {
+      version: this.version,
+      operations: this.buildOperationsMap()
+    };
+  }
+  async 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)) };
+    }
+  }
+  buildOperationsMap() {
+    const result = {};
+    const setNested = (path, meta) => {
+      const parts = path.split(".");
+      let current = result;
+      for (let i = 0;i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!current[part] || "type" in current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+      current[parts[parts.length - 1]] = meta;
+    };
+    for (const [name, def] of Object.entries(this.queries)) {
+      setNested(name, { type: "query" });
+    }
+    for (const [name, def] of Object.entries(this.mutations)) {
+      const meta = { type: "mutation" };
+      if (def._optimistic) {
+        meta.optimistic = def._optimistic;
+      }
+      setNested(name, meta);
+    }
+    return result;
+  }
+  handleWebSocket(ws) {
+    const clientId = `client_${++this.connectionCounter}`;
+    const conn = {
+      id: clientId,
+      ws,
+      subscriptions: new Map
+    };
+    this.connections.set(clientId, conn);
+    this.stateManager.addClient({
+      id: clientId,
+      send: (msg) => {
+        ws.send(JSON.stringify(msg));
+      }
+    });
+    ws.onmessage = (event) => {
+      this.handleMessage(conn, event.data);
+    };
+    ws.onclose = () => {
+      this.handleDisconnect(conn);
+    };
+  }
+  handleMessage(conn, data) {
+    try {
+      const message = JSON.parse(data);
+      switch (message.type) {
+        case "handshake":
+          this.handleHandshake(conn, message);
+          break;
+        case "subscribe":
+          this.handleSubscribe(conn, message);
+          break;
+        case "updateFields":
+          this.handleUpdateFields(conn, message);
+          break;
+        case "unsubscribe":
+          this.handleUnsubscribe(conn, message);
+          break;
+        case "query":
+          this.handleQuery(conn, message);
+          break;
+        case "mutation":
+          this.handleMutation(conn, message);
+          break;
+      }
+    } catch (error) {
+      conn.ws.send(JSON.stringify({
+        type: "error",
+        error: { code: "PARSE_ERROR", message: String(error) }
+      }));
+    }
+  }
+  handleHandshake(conn, message) {
+    conn.ws.send(JSON.stringify({
+      type: "handshake",
+      id: message.id,
+      version: this.version,
+      operations: this.buildOperationsMap()
+    }));
+  }
+  async handleSubscribe(conn, message) {
+    const { id, operation, input, fields } = message;
+    const sub = {
+      id,
+      operation,
+      input,
+      fields,
+      entityKeys: new Set,
+      cleanups: [],
+      lastData: null
+    };
+    conn.subscriptions.set(id, sub);
+    try {
+      await this.executeSubscription(conn, sub);
+    } catch (error) {
+      conn.ws.send(JSON.stringify({
+        type: "error",
+        id,
+        error: { code: "EXECUTION_ERROR", message: String(error) }
+      }));
+    }
+  }
+  async executeSubscription(conn, sub) {
+    const queryDef = this.queries[sub.operation];
+    if (!queryDef) {
+      throw new Error(`Query not found: ${sub.operation}`);
+    }
+    if (queryDef._input && sub.input !== undefined) {
+      const result = queryDef._input.safeParse(sub.input);
+      if (!result.success) {
+        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
+      }
+    }
+    const context = await this.contextFactory();
+    let isFirstUpdate = true;
+    const emitData = (data) => {
+      if (!data)
+        return;
+      const entityName = this.getEntityNameFromOutput(queryDef._output);
+      const entities = this.extractEntities(entityName, data);
+      for (const { entity, id, entityData } of entities) {
+        const entityKey = `${entity}:${id}`;
+        sub.entityKeys.add(entityKey);
+        this.stateManager.subscribe(conn.id, entity, id, sub.fields);
+        this.stateManager.emit(entity, id, entityData);
+      }
+      if (isFirstUpdate) {
+        conn.ws.send(JSON.stringify({
+          type: "data",
+          id: sub.id,
+          data
+        }));
+        isFirstUpdate = false;
+        sub.lastData = data;
+      } else {
+        const updates = this.computeUpdates(sub.lastData, data);
+        if (updates && Object.keys(updates).length > 0) {
+          conn.ws.send(JSON.stringify({
+            type: "update",
+            id: sub.id,
+            updates
+          }));
+        }
+        sub.lastData = data;
+      }
+    };
+    await runWithContext(this.ctx, context, async () => {
+      const resolver = queryDef._resolve;
+      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 result = resolver({
+        input: sub.input,
+        ctx: contextWithHelpers
+      });
+      if (isAsyncIterable(result)) {
+        for await (const value of result) {
+          emitData(value);
+        }
+      } else {
+        const value = await result;
+        emitData(value);
+      }
+    });
+  }
+  handleUpdateFields(conn, message) {
+    const sub = conn.subscriptions.get(message.id);
+    if (!sub)
+      return;
+    if (message.addFields?.includes("*")) {
+      sub.fields = "*";
+      for (const entityKey of sub.entityKeys) {
+        const [entity, id] = entityKey.split(":");
+        this.stateManager.updateSubscription(conn.id, entity, id, "*");
+      }
+      return;
+    }
+    if (message.setFields !== undefined) {
+      sub.fields = message.setFields;
+      for (const entityKey of sub.entityKeys) {
+        const [entity, id] = entityKey.split(":");
+        this.stateManager.updateSubscription(conn.id, entity, id, sub.fields);
+      }
+      return;
+    }
+    if (sub.fields === "*") {
+      return;
+    }
+    const fields = new Set(sub.fields);
+    if (message.addFields) {
+      for (const field of message.addFields) {
+        fields.add(field);
+      }
+    }
+    if (message.removeFields) {
+      for (const field of message.removeFields) {
+        fields.delete(field);
+      }
+    }
+    sub.fields = Array.from(fields);
+    for (const entityKey of sub.entityKeys) {
+      const [entity, id] = entityKey.split(":");
+      this.stateManager.updateSubscription(conn.id, entity, id, sub.fields);
+    }
+  }
+  handleUnsubscribe(conn, message) {
+    const sub = conn.subscriptions.get(message.id);
+    if (!sub)
+      return;
+    for (const cleanup of sub.cleanups) {
+      try {
+        cleanup();
+      } catch (e) {
+        console.error("Cleanup error:", e);
+      }
+    }
+    for (const entityKey of sub.entityKeys) {
+      const [entity, id] = entityKey.split(":");
+      this.stateManager.unsubscribe(conn.id, entity, id);
+    }
+    conn.subscriptions.delete(message.id);
+  }
+  async handleQuery(conn, message) {
+    try {
+      let input = message.input;
+      if (message.select) {
+        input = { ...message.input || {}, $select: message.select };
+      }
+      const result = await this.executeQuery(message.operation, input);
+      const selected = message.fields && !message.select ? this.applySelection(result, message.fields) : result;
+      conn.ws.send(JSON.stringify({
+        type: "result",
+        id: message.id,
+        data: selected
+      }));
+    } catch (error) {
+      conn.ws.send(JSON.stringify({
+        type: "error",
+        id: message.id,
+        error: { code: "EXECUTION_ERROR", message: String(error) }
+      }));
+    }
+  }
+  async handleMutation(conn, message) {
+    try {
+      const result = await this.executeMutation(message.operation, message.input);
+      const entityName = this.getEntityNameFromMutation(message.operation);
+      const entities = this.extractEntities(entityName, result);
+      for (const { entity, id, entityData } of entities) {
+        this.stateManager.emit(entity, id, entityData);
+      }
+      conn.ws.send(JSON.stringify({
+        type: "result",
+        id: message.id,
+        data: result
+      }));
+    } catch (error) {
+      conn.ws.send(JSON.stringify({
+        type: "error",
+        id: message.id,
+        error: { code: "EXECUTION_ERROR", message: String(error) }
+      }));
+    }
+  }
+  handleDisconnect(conn) {
+    for (const sub of conn.subscriptions.values()) {
+      for (const cleanup of sub.cleanups) {
+        try {
+          cleanup();
+        } catch (e) {
+          console.error("Cleanup error:", e);
+        }
+      }
+    }
+    this.stateManager.removeClient(conn.id);
+    this.connections.delete(conn.id);
+  }
+  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 resolverCtx = {
+          input: cleanInput,
+          ctx: context,
+          emit: () => {},
+          onCleanup: () => () => {}
+        };
+        const result = resolver(resolverCtx);
+        let data;
+        if (isAsyncIterable(result)) {
+          for await (const value of result) {
+            data = value;
+            break;
+          }
+          if (data === undefined) {
+            throw new Error(`Query ${name} returned empty stream`);
+          }
+        } else {
+          data = await result;
+        }
+        return this.processQueryResult(name, data, select);
+      });
+    } finally {
+      this.clearLoaders();
+    }
+  }
+  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)}`);
+      }
+    }
+    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 result = await resolver({
+          input,
+          ctx: context
+        });
+        const entityName = this.getEntityNameFromMutation(name);
+        const entities = this.extractEntities(entityName, result);
+        for (const { entity, id, entityData } of entities) {
+          this.stateManager.emit(entity, id, entityData);
+        }
+        return result;
+      });
+    } finally {
+      this.clearLoaders();
+    }
+  }
+  async handleRequest(req) {
+    const url = new URL(req.url);
+    if (req.method === "GET" && url.pathname.endsWith("/__lens/metadata")) {
+      return new Response(JSON.stringify(this.getMetadata()), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (req.method === "POST") {
+      try {
+        const body = await req.json();
+        if (this.queries[body.operation]) {
+          const result = await this.executeQuery(body.operation, body.input);
+          return new Response(JSON.stringify({ data: result }), {
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        if (this.mutations[body.operation]) {
+          const result = await this.executeMutation(body.operation, body.input);
+          return new Response(JSON.stringify({ data: result }), {
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        return new Response(JSON.stringify({ error: `Operation not found: ${body.operation}` }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ error: String(error) }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    return new Response("Method not allowed", { status: 405 });
+  }
+  async listen(port) {
+    this.server = Bun.serve({
+      port,
+      fetch: (req, server) => {
+        if (server.upgrade(req)) {
+          return;
+        }
+        return this.handleRequest(req);
+      },
+      websocket: {
+        message: (ws, message) => {
+          const conn = this.findConnectionByWs(ws);
+          if (conn) {
+            this.handleMessage(conn, String(message));
+          }
+        },
+        close: (ws) => {
+          const conn = this.findConnectionByWs(ws);
+          if (conn) {
+            this.handleDisconnect(conn);
+          }
+        }
+      }
+    });
+    console.log(`Lens server listening on port ${port}`);
+  }
+  async close() {
+    if (this.server && typeof this.server.stop === "function") {
+      this.server.stop();
+    }
+    this.server = null;
+  }
+  findConnectionByWs(ws) {
+    for (const conn of this.connections.values()) {
+      if (conn.ws === ws) {
+        return conn;
+      }
+    }
+    return;
+  }
+  getEntityNameFromOutput(output) {
+    if (!output)
+      return "unknown";
+    if (typeof output === "object" && output !== null) {
+      if ("_name" in output) {
+        return output._name;
+      }
+      if ("name" in output) {
+        return output.name;
+      }
+    }
+    if (Array.isArray(output) && output.length > 0) {
+      const first = output[0];
+      if (typeof first === "object" && first !== null) {
+        if ("_name" in first) {
+          return first._name;
+        }
+        if ("name" in first) {
+          return first.name;
+        }
+      }
+    }
+    return "unknown";
+  }
+  getEntityNameFromMutation(name) {
+    const mutationDef = this.mutations[name];
+    if (!mutationDef)
+      return "unknown";
+    return this.getEntityNameFromOutput(mutationDef._output);
+  }
+  extractEntities(entityName, data) {
+    const results = [];
+    if (!data)
+      return results;
+    if (Array.isArray(data)) {
+      for (const item of data) {
+        if (item && typeof item === "object" && "id" in item) {
+          results.push({
+            entity: entityName,
+            id: String(item.id),
+            entityData: item
+          });
+        }
+      }
+    } else if (typeof data === "object" && "id" in data) {
+      results.push({
+        entity: entityName,
+        id: String(data.id),
+        entityData: data
+      });
+    }
+    return results;
+  }
+  applySelection(data, fields) {
+    if (fields === "*" || !data)
+      return data;
+    if (Array.isArray(data)) {
+      return data.map((item) => this.applySelectionToObject(item, fields));
+    }
+    return this.applySelectionToObject(data, fields);
+  }
+  applySelectionToObject(data, fields) {
+    if (!data || typeof data !== "object")
+      return null;
+    const result = {};
+    const obj = data;
+    if ("id" in obj) {
+      result.id = obj.id;
+    }
+    if (Array.isArray(fields)) {
+      for (const field of fields) {
+        if (field in obj) {
+          result[field] = obj[field];
+        }
+      }
+      return result;
+    }
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === false)
+        continue;
+      const dataValue = obj[key];
+      if (value === true) {
+        result[key] = dataValue;
+      } else if (typeof value === "object" && value !== null) {
+        const nestedSelect = value.select ?? value;
+        if (Array.isArray(dataValue)) {
+          result[key] = dataValue.map((item) => this.applySelectionToObject(item, nestedSelect));
+        } else if (dataValue !== null && typeof dataValue === "object") {
+          result[key] = this.applySelectionToObject(dataValue, nestedSelect);
+        } else {
+          result[key] = dataValue;
+        }
+      }
+    }
+    return result;
+  }
+  async executeEntityResolvers(entityName, data, select) {
+    if (!data || !select || !this.resolvers)
+      return data;
+    const result = { ...data };
+    for (const [fieldName, fieldSelect] of Object.entries(select)) {
+      if (fieldSelect === false || fieldSelect === true)
+        continue;
+      const resolver = this.resolvers.getResolver(entityName, fieldName);
+      if (!resolver)
+        continue;
+      if (isBatchResolver(resolver)) {
+        const loaderKey = `${entityName}.${fieldName}`;
+        if (!this.loaders.has(loaderKey)) {
+          this.loaders.set(loaderKey, new DataLoader(async (parents) => {
+            return resolver.batch(parents);
+          }));
+        }
+        const loader = this.loaders.get(loaderKey);
+        result[fieldName] = await loader.load(data);
+      } else {
+        result[fieldName] = await resolver(data);
+      }
+      const nestedSelect = fieldSelect.select;
+      if (nestedSelect && result[fieldName]) {
+        const relationData = result[fieldName];
+        const targetEntity = this.getRelationTargetEntity(entityName, fieldName);
+        if (Array.isArray(relationData)) {
+          result[fieldName] = await Promise.all(relationData.map((item) => this.executeEntityResolvers(targetEntity, item, nestedSelect)));
+        } else {
+          result[fieldName] = await this.executeEntityResolvers(targetEntity, relationData, nestedSelect);
+        }
+      }
+    }
+    return result;
+  }
+  getRelationTargetEntity(entityName, fieldName) {
+    const entityDef = this.entities[entityName];
+    if (!entityDef)
+      return fieldName;
+    const fields = entityDef.fields;
+    if (!fields)
+      return fieldName;
+    const fieldDef = fields[fieldName];
+    if (!fieldDef)
+      return fieldName;
+    if (fieldDef._type === "hasMany" || fieldDef._type === "hasOne" || fieldDef._type === "belongsTo") {
+      return fieldDef._target ?? fieldName;
+    }
+    return fieldName;
+  }
+  serializeEntity(entityName, data) {
+    if (data === null)
+      return null;
+    const entityDef = this.entities[entityName];
+    if (!entityDef)
+      return data;
+    const fields = entityDef.fields;
+    if (!fields)
+      return data;
+    const result = {};
+    for (const [fieldName, value] of Object.entries(data)) {
+      const fieldType = fields[fieldName];
+      if (!fieldType) {
+        result[fieldName] = value;
+        continue;
+      }
+      if (value === null || value === undefined) {
+        result[fieldName] = value;
+        continue;
+      }
+      if (fieldType._type === "hasMany" || fieldType._type === "belongsTo" || fieldType._type === "hasOne") {
+        const targetEntity = fieldType._target;
+        if (targetEntity && Array.isArray(value)) {
+          result[fieldName] = value.map((item) => this.serializeEntity(targetEntity, item));
+        } else if (targetEntity && typeof value === "object") {
+          result[fieldName] = this.serializeEntity(targetEntity, value);
+        } else {
+          result[fieldName] = value;
+        }
+        continue;
+      }
+      if (typeof fieldType.serialize === "function") {
+        try {
+          result[fieldName] = fieldType.serialize(value);
+        } catch (error) {
+          console.warn(`Failed to serialize field ${entityName}.${fieldName}:`, error);
+          result[fieldName] = value;
+        }
+      } else {
+        result[fieldName] = value;
+      }
+    }
+    return result;
+  }
+  async processQueryResult(queryName, data, select) {
+    if (data === null || data === undefined)
+      return data;
+    const queryDef = this.queries[queryName];
+    const entityName = this.getEntityNameFromOutput(queryDef?._output);
+    if (Array.isArray(data)) {
+      const processedItems = await Promise.all(data.map(async (item) => {
+        let result2 = item;
+        if (select && this.resolvers) {
+          result2 = await this.executeEntityResolvers(entityName, item, select);
+        }
+        if (select) {
+          result2 = this.applySelection(result2, select);
+        }
+        if (entityName) {
+          return this.serializeEntity(entityName, result2);
+        }
+        return result2;
+      }));
+      return processedItems;
+    }
+    let result = data;
+    if (select && this.resolvers) {
+      result = await this.executeEntityResolvers(entityName, data, select);
+    }
+    if (select) {
+      result = this.applySelection(result, select);
+    }
+    if (entityName && typeof result === "object" && result !== null) {
+      return this.serializeEntity(entityName, result);
+    }
+    return result;
+  }
+  computeUpdates(oldData, newData) {
+    if (!oldData || !newData)
+      return null;
+    if (typeof oldData !== "object" || typeof newData !== "object")
+      return null;
+    const updates = {};
+    const oldObj = oldData;
+    const newObj = newData;
+    for (const key of Object.keys(newObj)) {
+      const oldValue = oldObj[key];
+      const newValue = newObj[key];
+      if (!this.deepEqual(oldValue, newValue)) {
+        updates[key] = createUpdate(oldValue, newValue);
+      }
+    }
+    return Object.keys(updates).length > 0 ? updates : null;
+  }
+  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 aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (const key of aKeys) {
+      if (!this.deepEqual(aObj[key], bObj[key]))
+        return false;
+    }
+    return true;
+  }
+  clearLoaders() {
+    for (const loader of this.loaders.values()) {
+      loader.clear();
+    }
+    this.loaders.clear();
+  }
+}
+function isAsyncIterable(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
+}
+function createServer(config) {
+  const server = new LensServerImpl(config);
+  return server;
+}
+// src/sse/handler.ts
+class SSEHandler {
+  stateManager;
+  heartbeatInterval;
+  clients = new Map;
+  clientCounter = 0;
+  constructor(config) {
+    this.stateManager = config.stateManager;
+    this.heartbeatInterval = config.heartbeatInterval ?? 30000;
+  }
+  handleConnection(req) {
+    const clientId = `sse_${++this.clientCounter}_${Date.now()}`;
+    const encoder = new TextEncoder;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const stateClient = {
+          id: clientId,
+          send: (msg) => {
+            try {
+              const data = `data: ${JSON.stringify(msg)}
+
+`;
+              controller.enqueue(encoder.encode(data));
+            } catch {
+              this.removeClient(clientId);
+            }
+          }
+        };
+        this.stateManager.addClient(stateClient);
+        controller.enqueue(encoder.encode(`event: connected
+data: ${JSON.stringify({ clientId })}
+
+`));
+        const heartbeat = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(`: heartbeat ${Date.now()}
+
+`));
+          } catch {
+            this.removeClient(clientId);
+          }
+        }, this.heartbeatInterval);
+        this.clients.set(clientId, { controller, heartbeat });
+      },
+      cancel: () => {
+        this.removeClient(clientId);
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  }
+  removeClient(clientId) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      clearInterval(client.heartbeat);
+      this.clients.delete(clientId);
+    }
+    this.stateManager.removeClient(clientId);
+  }
+  closeClient(clientId) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      try {
+        client.controller.close();
+      } catch {}
+      this.removeClient(clientId);
+    }
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  getClientIds() {
+    return Array.from(this.clients.keys());
+  }
+  closeAll() {
+    for (const clientId of this.clients.keys()) {
+      this.closeClient(clientId);
+    }
+  }
+}
+function createSSEHandler(config) {
+  return new SSEHandler(config);
+}
+export {
+  createServer,
+  createSSEHandler,
+  createGraphStateManager,
+  SSEHandler,
+  GraphStateManager
+};