@sylphx/lens-server 3.0.1 → 4.0.0

package/dist/index.js

@@ -41,12 +41,11 @@ import {
   createResolverFromEntity,
   flattenRouter,
   hashValue,
-  hasInlineResolvers,
-  isEntityDef,
   isLiveQueryDef,
   isModelDef,
   isMutationDef,
   isQueryDef,
+  isSubscriptionDef,
   mergeModelCollections,
   toOps,
   valuesEqual
@@ -298,17 +297,19 @@ var noopLogger = {};
 class LensServerImpl {
   queries;
   mutations;
+  subscriptions;
   entities;
   resolverMap;
   contextFactory;
   version;
   logger;
   ctx = createContext();
-  loaders = new Map;
   pluginManager;
+  typeNameCache = new WeakMap;
   constructor(config) {
     const queries = { ...config.queries ?? {} };
     const mutations = { ...config.mutations ?? {} };
+    const subscriptions = { ...config.subscriptions ?? {} };
     if (config.router) {
       const flattened = flattenRouter(config.router);
       for (const [path, procedure] of flattened) {
@@ -316,11 +317,14 @@ class LensServerImpl {
           queries[path] = procedure;
         } else if (isMutationDef(procedure)) {
           mutations[path] = procedure;
+        } else if (isSubscriptionDef(procedure)) {
+          subscriptions[path] = procedure;
         }
       }
     }
     this.queries = queries;
     this.mutations = mutations;
+    this.subscriptions = subscriptions;
     const autoCollected = config.router ? collectModelsFromRouter(config.router) : collectModelsFromOperations(queries, mutations);
     const entitiesFromConfig = config.entities ?? {};
     const mergedModels = mergeModelCollections(autoCollected, entitiesFromConfig);
@@ -334,7 +338,7 @@ class LensServerImpl {
     }
     const entities = {};
     for (const [name, model] of mergedModels) {
-      if (isEntityDef(model) || isModelDef(model)) {
+      if (isModelDef(model)) {
         entities[name] = model;
       }
     }
@@ -366,6 +370,11 @@ class LensServerImpl {
         def._name = name;
       }
     }
+    for (const [name, def] of Object.entries(this.subscriptions)) {
+      if (def && typeof def === "object") {
+        def._name = name;
+      }
+    }
   }
   validateDefinitions() {
     for (const [name, def] of Object.entries(this.queries)) {
@@ -378,6 +387,11 @@ class LensServerImpl {
         throw new Error(`Invalid mutation definition: ${name}`);
       }
     }
+    for (const [name, def] of Object.entries(this.subscriptions)) {
+      if (!isSubscriptionDef(def)) {
+        throw new Error(`Invalid subscription definition: ${name}`);
+      }
+    }
   }
   buildResolverMap(explicitResolvers, entities) {
     const resolverMap = new Map;
@@ -390,14 +404,12 @@ class LensServerImpl {
       }
     }
     for (const [name, entity] of Object.entries(entities)) {
-      if (!isEntityDef(entity) && !isModelDef(entity))
+      if (!isModelDef(entity))
         continue;
       if (resolverMap.has(name))
         continue;
-      if (hasInlineResolvers(entity)) {
-        const resolver = createResolverFromEntity(entity);
-        resolverMap.set(name, resolver);
-      }
+      const resolver = createResolverFromEntity(entity);
+      resolverMap.set(name, resolver);
     }
     return resolverMap.size > 0 ? resolverMap : undefined;
   }
@@ -430,7 +442,8 @@ class LensServerImpl {
     const { path, input } = op;
     const isQuery = !!this.queries[path];
     const isMutation = !!this.mutations[path];
-    if (!isQuery && !isMutation) {
+    const isSubscription = !!this.subscriptions[path];
+    if (!isQuery && !isMutation && !isSubscription) {
       return {
         subscribe: (observer) => {
           observer.next?.({
@@ -443,8 +456,106 @@ class LensServerImpl {
         }
       };
     }
+    if (isSubscription) {
+      return this.executeSubscription(path, input);
+    }
     return this.executeAsObservable(path, input, isQuery);
   }
+  executeSubscription(path, input) {
+    return {
+      subscribe: (observer) => {
+        let cancelled = false;
+        const cleanups = [];
+        (async () => {
+          try {
+            const def = this.subscriptions[path];
+            if (!def) {
+              observer.next?.({
+                $: "error",
+                error: `Subscription not found: ${path}`,
+                code: "NOT_FOUND"
+              });
+              observer.complete?.();
+              return;
+            }
+            if (def._input && input !== undefined) {
+              if (def._input.safeParse) {
+                const result = def._input.safeParse(input);
+                if (!result.success) {
+                  observer.next?.({
+                    $: "error",
+                    error: `Invalid input: ${JSON.stringify(result.error)}`,
+                    code: "VALIDATION_ERROR"
+                  });
+                  observer.complete?.();
+                  return;
+                }
+              } else {
+                try {
+                  def._input.parse(input);
+                } catch (e) {
+                  observer.next?.({
+                    $: "error",
+                    error: `Invalid input: ${e instanceof Error ? e.message : String(e)}`,
+                    code: "VALIDATION_ERROR"
+                  });
+                  observer.complete?.();
+                  return;
+                }
+              }
+            }
+            const context = await this.contextFactory();
+            const subscriber = def._subscriber;
+            if (!subscriber) {
+              observer.next?.({
+                $: "error",
+                error: `Subscription ${path} has no subscriber`,
+                code: "NO_SUBSCRIBER"
+              });
+              observer.complete?.();
+              return;
+            }
+            const publisher = subscriber({ input, ctx: context });
+            if (publisher) {
+              const emit = createEmit((command) => {
+                if (cancelled)
+                  return;
+                if (command.type === "full") {
+                  observer.next?.({ $: "snapshot", data: command.data });
+                }
+              }, "scalar");
+              publisher({
+                emit,
+                onCleanup: (fn) => {
+                  cleanups.push(fn);
+                  return fn;
+                }
+              });
+            }
+          } catch (error) {
+            for (const fn of cleanups) {
+              try {
+                fn();
+              } catch {}
+            }
+            if (!cancelled) {
+              const errMsg = error instanceof Error ? error.message : String(error);
+              observer.next?.({ $: "error", error: errMsg, code: "INTERNAL_ERROR" });
+              observer.complete?.();
+            }
+          }
+        })();
+        return {
+          unsubscribe: () => {
+            cancelled = true;
+            for (const fn of cleanups) {
+              fn();
+            }
+          }
+        };
+      }
+    };
+  }
   executeAsObservable(path, input, isQuery) {
     return {
       subscribe: (observer) => {
@@ -483,15 +594,29 @@ class LensServerImpl {
               cleanInput = Object.keys(rest).length > 0 ? rest : undefined;
             }
             if (def._input && cleanInput !== undefined) {
-              const result = def._input.safeParse(cleanInput);
-              if (!result.success) {
-                observer.next?.({
-                  $: "error",
-                  error: `Invalid input: ${JSON.stringify(result.error)}`,
-                  code: "VALIDATION_ERROR"
-                });
-                observer.complete?.();
-                return;
+              if (def._input.safeParse) {
+                const result = def._input.safeParse(cleanInput);
+                if (!result.success) {
+                  observer.next?.({
+                    $: "error",
+                    error: `Invalid input: ${JSON.stringify(result.error)}`,
+                    code: "VALIDATION_ERROR"
+                  });
+                  observer.complete?.();
+                  return;
+                }
+              } else {
+                try {
+                  def._input.parse(cleanInput);
+                } catch (e) {
+                  observer.next?.({
+                    $: "error",
+                    error: `Invalid input: ${e instanceof Error ? e.message : String(e)}`,
+                    code: "VALIDATION_ERROR"
+                  });
+                  observer.complete?.();
+                  return;
+                }
               }
             }
             const context = await this.contextFactory();
@@ -527,16 +652,34 @@ class LensServerImpl {
                 observer.next?.({ $: "ops", ops });
               }) : undefined;
               const lensContext = { ...context, emit, onCleanup };
-              const result = resolver({ args: cleanInput, input: cleanInput, ctx: lensContext });
+              const result = resolver({ args: cleanInput, ctx: lensContext });
               if (isAsyncIterable(result)) {
-                for await (const value of result) {
-                  if (cancelled)
-                    break;
-                  const processed = await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit);
-                  emitIfChanged(processed);
-                }
-                if (!cancelled) {
-                  observer.complete?.();
+                try {
+                  for await (const value of result) {
+                    if (cancelled)
+                      break;
+                    const processed = await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit);
+                    emitIfChanged(processed);
+                  }
+                  if (!cancelled) {
+                    observer.complete?.();
+                  }
+                } catch (iterError) {
+                  for (const fn of cleanups) {
+                    try {
+                      fn();
+                    } catch {}
+                  }
+                  if (!cancelled) {
+                    const errMsg = iterError instanceof Error ? iterError.message : String(iterError);
+                    observer.next?.({
+                      $: "error",
+                      error: errMsg,
+                      code: "STREAM_ERROR"
+                    });
+                    observer.complete?.();
+                  }
+                  return;
                 }
               } else {
                 const value = await result;
@@ -548,7 +691,6 @@ class LensServerImpl {
                     try {
                       const publisher = liveQuery._subscriber({
                         args: cleanInput,
-                        input: cleanInput,
                         ctx: context
                       });
                       if (publisher) {
@@ -566,19 +708,26 @@ class LensServerImpl {
                     }
                   }
                 }
-                if (!isQuery && !cancelled) {
-                  observer.complete?.();
+                const hasLiveSubscriptions = cleanups.length > 0;
+                const isLiveQuery = isQuery && isLiveQueryDef(def) && def._subscriber;
+                if (!cancelled) {
+                  if (!isQuery || !hasLiveSubscriptions && !isLiveQuery) {
+                    observer.complete?.();
+                  }
                 }
               }
             });
           } catch (error) {
+            for (const fn of cleanups) {
+              try {
+                fn();
+              } catch {}
+            }
             if (!cancelled) {
               const errMsg = error instanceof Error ? error.message : String(error);
               observer.next?.({ $: "error", error: errMsg, code: "INTERNAL_ERROR" });
               observer.complete?.();
             }
-          } finally {
-            this.clearLoaders();
           }
         })();
         return {
@@ -645,17 +794,18 @@ class LensServerImpl {
     if (!data)
       return data;
     const nestedInputs = select ? extractNestedInputs(select) : undefined;
-    const processed = await this.resolveEntityFields(data, nestedInputs, context, "", onCleanup, createFieldEmit, new Set);
+    const requestLoaders = new Map;
+    const processed = await this.resolveEntityFields(data, nestedInputs, context, "", onCleanup, createFieldEmit, new Set, requestLoaders);
     if (select) {
       return applySelection(processed, select);
     }
     return processed;
   }
-  async resolveEntityFields(data, nestedInputs, context, fieldPath = "", onCleanup, createFieldEmit, visited = new Set) {
+  async resolveEntityFields(data, nestedInputs, context, fieldPath = "", onCleanup, createFieldEmit, visited = new Set, loaders = new Map) {
     if (!data || !this.resolverMap)
       return data;
     if (Array.isArray(data)) {
-      return Promise.all(data.map((item) => this.resolveEntityFields(item, nestedInputs, context, fieldPath, onCleanup, createFieldEmit, visited)));
+      return Promise.all(data.map((item) => this.resolveEntityFields(item, nestedInputs, context, fieldPath, onCleanup, createFieldEmit, visited, loaders)));
     }
     if (typeof data !== "object")
       return data;
@@ -682,11 +832,6 @@ class LensServerImpl {
       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, nestedInputs, context, currentPath, onCleanup, createFieldEmit, visited);
-        continue;
-      }
       const fieldMode = resolverDef.getFieldMode(field);
       if (fieldMode === "live") {
         try {
@@ -694,7 +839,7 @@ class LensServerImpl {
             result[field] = await resolverDef.resolveField(field, obj, args, context ?? {});
           } else {
             const loaderKey = `${typeName}.${field}`;
-            const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field, context ?? {});
+            const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field, context ?? {}, loaders);
             result[field] = await loader.load(obj);
           }
           const publisher = resolverDef.subscribeField(field, obj, args, context ?? {});
@@ -710,31 +855,12 @@ class LensServerImpl {
                   }
                 });
               }
-            } catch {}
-          }
-        } catch {
-          result[field] = null;
-        }
-      } else if (fieldMode === "subscribe") {
-        try {
-          result[field] = null;
-          if (createFieldEmit && onCleanup) {
-            try {
-              const fieldEmit = createFieldEmit(currentPath);
-              if (fieldEmit) {
-                const legacyCtx = {
-                  ...context ?? {},
-                  emit: fieldEmit,
-                  onCleanup: (fn) => {
-                    onCleanup(fn);
-                    return fn;
-                  }
-                };
-                resolverDef.subscribeFieldLegacy(field, obj, args, legacyCtx);
-              }
-            } catch {}
+            } catch (subscribeError) {
+              this.logger.error?.(`Field subscription error at ${currentPath}:`, subscribeError instanceof Error ? subscribeError.message : String(subscribeError));
+            }
           }
-        } catch {
+        } catch (resolveError) {
+          this.logger.error?.(`Live field resolution error at ${currentPath}:`, resolveError instanceof Error ? resolveError.message : String(resolveError));
           result[field] = null;
         }
       } else {
@@ -743,14 +869,15 @@ class LensServerImpl {
             result[field] = await resolverDef.resolveField(field, obj, args, context ?? {});
           } else {
             const loaderKey = `${typeName}.${field}`;
-            const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field, context ?? {});
+            const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field, context ?? {}, loaders);
             result[field] = await loader.load(obj);
           }
-        } catch {
+        } catch (resolveError) {
+          this.logger.error?.(`Field resolution error at ${currentPath}:`, resolveError instanceof Error ? resolveError.message : String(resolveError));
           result[field] = null;
         }
       }
-      result[field] = await this.resolveEntityFields(result[field], nestedInputs, context, currentPath, onCleanup, createFieldEmit, visited);
+      result[field] = await this.resolveEntityFields(result[field], nestedInputs, context, currentPath, onCleanup, createFieldEmit, visited, loaders);
     }
     return result;
   }
@@ -759,16 +886,21 @@ class LensServerImpl {
       return obj.__typename;
     if ("_type" in obj)
       return obj._type;
+    if (this.typeNameCache.has(obj)) {
+      return this.typeNameCache.get(obj);
+    }
     let bestMatch;
     for (const [name, def] of Object.entries(this.entities)) {
-      if (!isEntityDef(def))
+      if (!isModelDef(def))
         continue;
       const score = this.getEntityMatchScore(obj, def);
       if (score >= 0.5 && (!bestMatch || score > bestMatch.score)) {
         bestMatch = { name, score };
       }
     }
-    return bestMatch?.name;
+    const result = bestMatch?.name;
+    this.typeNameCache.set(obj, result);
+    return result;
   }
   getEntityMatchScore(obj, entityDef) {
     const fieldNames = Object.keys(entityDef.fields);
@@ -777,8 +909,8 @@ class LensServerImpl {
     const matchingFields = fieldNames.filter((field) => (field in obj));
     return matchingFields.length / fieldNames.length;
   }
-  getOrCreateLoaderForField(loaderKey, resolverDef, fieldName, context) {
-    let loader = this.loaders.get(loaderKey);
+  getOrCreateLoaderForField(loaderKey, resolverDef, fieldName, context, loaders) {
+    let loader = loaders.get(loaderKey);
     if (!loader) {
       loader = new DataLoader(async (parents) => {
         const results = [];
@@ -792,13 +924,10 @@ class LensServerImpl {
         }
         return results;
       });
-      this.loaders.set(loaderKey, loader);
+      loaders.set(loaderKey, loader);
     }
     return loader;
   }
-  clearLoaders() {
-    this.loaders.clear();
-  }
   buildOperationsMap() {
     const result = {};
     const setNested = (path, meta) => {
@@ -828,13 +957,17 @@ class LensServerImpl {
       return;
     };
     for (const [name, def] of Object.entries(this.queries)) {
-      const isSubscription = def._resolve?.constructor?.name === "AsyncGeneratorFunction" || def._resolve?.constructor?.name === "GeneratorFunction";
-      const opType = isSubscription ? "subscription" : "query";
+      const isAsyncGenerator = def._resolve?.constructor?.name === "AsyncGeneratorFunction" || def._resolve?.constructor?.name === "GeneratorFunction";
+      const isLive = isLiveQueryDef(def);
+      const opType = isAsyncGenerator ? "subscription" : "query";
       const returnType = getReturnTypeName(def._output);
       const meta = { type: opType };
       if (returnType) {
         meta.returnType = returnType;
       }
+      if (isLive) {
+        meta.live = true;
+      }
       this.pluginManager.runEnhanceOperationMeta({
         path: name,
         type: opType,
@@ -857,6 +990,20 @@ class LensServerImpl {
       });
       setNested(name, meta);
     }
+    for (const [name, def] of Object.entries(this.subscriptions)) {
+      const returnType = getReturnTypeName(def._output);
+      const meta = { type: "subscription" };
+      if (returnType) {
+        meta.returnType = returnType;
+      }
+      this.pluginManager.runEnhanceOperationMeta({
+        path: name,
+        type: "subscription",
+        meta,
+        definition: def
+      });
+      setNested(name, meta);
+    }
     return result;
   }
   getPluginManager() {
@@ -1122,8 +1269,7 @@ function createHTTPHandler(server, options = {}) {
         });
       }
       try {
-        const operationPath2 = body.operation ?? body.path;
-        if (!operationPath2) {
+        if (!body.path) {
           return new Response(JSON.stringify({ error: "Missing operation path" }), {
             status: 400,
             headers: {
@@ -1133,7 +1279,7 @@ function createHTTPHandler(server, options = {}) {
           });
         }
         const result2 = await firstValueFrom(server.execute({
-          path: operationPath2,
+          path: body.path,
           input: body.input
         }));
         if (isError(result2)) {
@@ -1273,38 +1419,73 @@ async function handleWebMutation(server, path, request) {
 }
 function handleWebSSE(server, path, url, signal) {
   const inputParam = url.searchParams.get("input");
-  const input = inputParam ? JSON.parse(inputParam) : undefined;
+  let input;
+  if (inputParam) {
+    try {
+      input = JSON.parse(inputParam);
+    } catch (parseError) {
+      const encoder = new TextEncoder;
+      const errorStream = new ReadableStream({
+        start(controller) {
+          const errMsg = parseError instanceof Error ? parseError.message : "Invalid JSON";
+          const data = `event: error
+data: ${JSON.stringify({ error: `Invalid input JSON: ${errMsg}` })}
+
+`;
+          controller.enqueue(encoder.encode(data));
+          controller.close();
+        }
+      });
+      return new Response(errorStream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    }
+  }
   const stream = new ReadableStream({
     start(controller) {
       const encoder = new TextEncoder;
-      const result = server.execute({ path, input });
-      if (result && typeof result === "object" && "subscribe" in result) {
-        const observable = result;
-        const subscription = observable.subscribe({
-          next: (value) => {
-            const data = `data: ${JSON.stringify(value.data)}
+      try {
+        const result = server.execute({ path, input });
+        if (result && typeof result === "object" && "subscribe" in result) {
+          const observable = result;
+          const subscription = observable.subscribe({
+            next: (value) => {
+              const data = `data: ${JSON.stringify(value.data)}
 
 `;
-            controller.enqueue(encoder.encode(data));
-          },
-          error: (err) => {
-            const data = `event: error
+              controller.enqueue(encoder.encode(data));
+            },
+            error: (err) => {
+              const data = `event: error
 data: ${JSON.stringify({ error: err.message })}
 
 `;
-            controller.enqueue(encoder.encode(data));
-            controller.close();
-          },
-          complete: () => {
-            controller.close();
-          }
-        });
-        if (signal) {
-          signal.addEventListener("abort", () => {
-            subscription.unsubscribe();
-            controller.close();
+              controller.enqueue(encoder.encode(data));
+              controller.close();
+            },
+            complete: () => {
+              controller.close();
+            }
           });
+          if (signal) {
+            signal.addEventListener("abort", () => {
+              subscription.unsubscribe();
+              controller.close();
+            });
+          }
         }
+      } catch (execError) {
+        const errMsg = execError instanceof Error ? execError.message : "Internal error";
+        const data = `event: error
+data: ${JSON.stringify({ error: errMsg })}
+
+`;
+        controller.enqueue(encoder.encode(data));
+        controller.close();
       }
     }
   });
@@ -1396,7 +1577,9 @@ function createWSHandler(server, options = {}) {
         ...id !== undefined && { id },
         error: { code, message }
       }));
-    } catch {}
+    } catch (sendError) {
+      logger.debug?.(`Failed to send error to client ${conn.id}:`, sendError instanceof Error ? sendError.message : String(sendError));
+    }
   }
   const connections = new Map;
   const wsToConnection = new WeakMap;
@@ -1643,7 +1826,12 @@ function createWSHandler(server, options = {}) {
     }
     sub.fields = newFields;
     for (const entityKey of sub.entityKeys) {
-      const [entity, entityId] = entityKey.split(":");
+      const parts = entityKey.split(":");
+      if (parts.length < 2) {
+        logger.warn?.(`Invalid entityKey format: "${entityKey}" (expected "Entity:id")`);
+        continue;
+      }
+      const [entity, entityId] = parts;
       await pluginManager.runOnUpdateFields({
         clientId: conn.id,
         subscriptionId: sub.id,
@@ -1956,6 +2144,17 @@ var DEFAULT_STORAGE_CONFIG = {
 function makeKey(entity, entityId) {
   return `${entity}:${entityId}`;
 }
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const sortedKeys = Object.keys(value).sort();
+  const pairs = sortedKeys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  return `{${pairs.join(",")}}`;
+}
 function computePatch(oldState, newState) {
   const patch = [];
   const oldKeys = new Set(Object.keys(oldState));
@@ -1965,7 +2164,7 @@ function computePatch(oldState, newState) {
     const newValue = newState[key];
     if (!oldKeys.has(key)) {
       patch.push({ op: "add", path: `/${key}`, value: newValue });
-    } else if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+    } else if (stableStringify(oldValue) !== stableStringify(newValue)) {
       patch.push({ op: "replace", path: `/${key}`, value: newValue });
     }
   }
@@ -1977,7 +2176,7 @@ function computePatch(oldState, newState) {
   return patch;
 }
 function hashState(state) {
-  return JSON.stringify(state);
+  return stableStringify(state);
 }
 function memoryStorage(config = {}) {
   const cfg = { ...DEFAULT_STORAGE_CONFIG, ...config };
@@ -2288,7 +2487,7 @@ function sugarToPipeline(sugar, entityType, inputFields) {
             $do: "entity.delete",
             $with: {
               type: entity,
-              id: { id: $input("id") }
+              id: $input("id")
             },
             $as: "result"
           }
@@ -2499,15 +2698,20 @@ class OperationLog {
     if (!removed)
       return;
     this.totalMemory -= removed.patchSize;
-    const indices = this.entityIndex.get(removed.entityKey);
-    if (indices && indices.length > 0) {
-      indices.shift();
-      if (indices.length === 0) {
+    for (const indices of this.entityIndex.values()) {
+      for (let i = 0;i < indices.length; i++) {
+        indices[i]--;
+      }
+    }
+    const removedEntityIndices = this.entityIndex.get(removed.entityKey);
+    if (removedEntityIndices && removedEntityIndices.length > 0) {
+      removedEntityIndices.shift();
+      if (removedEntityIndices.length === 0) {
         this.entityIndex.delete(removed.entityKey);
         this.oldestVersionIndex.delete(removed.entityKey);
         this.newestVersionIndex.delete(removed.entityKey);
       } else {
-        const nextEntry = this.entries[indices[0] - 1];
+        const nextEntry = this.entries[removedEntityIndices[0]];
         if (nextEntry) {
           this.oldestVersionIndex.set(removed.entityKey, nextEntry.version);
         }