@peerbit/document 6.0.7-aa577a5 → 6.0.7-cccc078

package/dist/src/search.js

@@ -8,18 +8,20 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { field, serialize, variant } from "@dao-xyz/borsh";
-import { BORSH_ENCODING, Entry } from "@peerbit/log";
-import { Program } from "@peerbit/program";
+import { Cache } from "@peerbit/cache";
+import { PublicSignKey, sha256Base64Sync, } from "@peerbit/crypto";
 import * as types from "@peerbit/document-interface";
-import { RPC, queryAll, MissingResponsesError } from "@peerbit/rpc";
+import * as indexerTypes from "@peerbit/indexer-interface";
+import { HashmapIndex } from "@peerbit/indexer-simple";
+import { BORSH_ENCODING, Entry } from "@peerbit/log";
 import { logger as loggerFn } from "@peerbit/logger";
-import { PublicSignKey, sha256Base64Sync } from "@peerbit/crypto";
+import { Program } from "@peerbit/program";
+import { MissingResponsesError, RPC, queryAll, } from "@peerbit/rpc";
 import { SharedLog } from "@peerbit/shared-log";
-import { concat, fromString } from "uint8arrays";
 import { SilentDelivery } from "@peerbit/stream-interface";
 import { AbortError } from "@peerbit/time";
-import { Cache } from "@peerbit/cache";
-import { HashmapIndexEngine } from "@peerbit/document-index-simple";
+import { concat, fromString } from "uint8arrays";
+import { copySerialization } from "./borsh.js";
 import { MAX_BATCH_SIZE } from "./constants.js";
 const logger = loggerFn({ module: "document-index" });
 let Operation = class Operation /* <T> */ {
@@ -37,10 +39,7 @@ let PutOperation = class PutOperation extends Operation /* <T> */ {
     /* _value?: T; */
     constructor(props) {
         super();
-        if (props) {
-            this.data = props.data;
-            /* this._value = props.value; */
-        }
+        this.data = props.data;
     }
 };
 __decorate([
@@ -76,8 +75,8 @@ let DeleteOperation = class DeleteOperation extends Operation {
     }
 };
 __decorate([
-    field({ type: types.IdKey }),
-    __metadata("design:type", types.IdKey)
+    field({ type: indexerTypes.IdKey }),
+    __metadata("design:type", indexerTypes.IdKey)
 ], DeleteOperation.prototype, "key", void 0);
 DeleteOperation = __decorate([
     variant(2),
@@ -112,33 +111,44 @@ const dedup = (allResult, dedupBy) => {
     const unique = new Set();
     const dedup = [];
     for (const result of allResult) {
-        const key = types.toIdeable(dedupBy(result));
-        if (unique.has(key)) {
+        const key = indexerTypes.toId(dedupBy(result));
+        const primitive = key.primitive;
+        if (unique.has(primitive)) {
             continue;
         }
-        unique.add(key);
+        unique.add(primitive);
         dedup.push(result);
     }
     return dedup;
 };
 const DEFAULT_INDEX_BY = "id";
+const isTransformerWithFunction = (options) => {
+    return options.transform != null;
+};
 let DocumentIndex = class DocumentIndex extends Program {
     _query;
-    engine;
-    type;
+    // Original document representation
+    documentType;
+    // transform options
+    transformer;
+    // The indexed document wrapped in a context
+    wrappedIndexedType;
+    // The database type, for recursive indexing
     dbType;
+    indexedTypeIsDocumentType;
     // Index key
     indexBy;
-    indexByArr;
     indexByResolver;
+    index;
     // Transformation, indexer
-    fields;
+    /* fields: IndexableFields<T, I>; */
     _valueEncoding;
     _sync;
     _log;
     _resolverProgramCache;
     _resolverCache;
     _isProgramValues;
+    _resultQueue;
     constructor(properties) {
         super();
         this._query = properties?.query || new RPC();
@@ -148,35 +158,55 @@ let DocumentIndex = class DocumentIndex extends Program {
     }
     async open(properties) {
         this._log = properties.log;
-        this.type = properties.type;
+        this.documentType = properties.documentType;
+        this.indexedTypeIsDocumentType =
+            !properties.transform?.type ||
+                properties.transform?.type === properties.documentType;
+        class IndexedClassWithContex {
+            __context;
+            constructor(value, context) {
+                Object.assign(this, value);
+                this.__context = context;
+            }
+        }
+        __decorate([
+            field({ type: types.Context }),
+            __metadata("design:type", types.Context)
+        ], IndexedClassWithContex.prototype, "__context", void 0);
+        // copy all prototype values from indexedType to IndexedClassWithContex
+        copySerialization((properties.transform?.type || properties.documentType), IndexedClassWithContex);
+        this.wrappedIndexedType = IndexedClassWithContex;
         // if this.type is a class that extends Program we want to do special functionality
-        this._isProgramValues = this.type instanceof Program;
+        this._isProgramValues = this.documentType instanceof Program;
         this.dbType = properties.dbType;
+        this._resultQueue = new Map();
         this._sync = properties.sync;
-        this.fields = properties.fields;
-        this.indexBy = properties.indexBy || DEFAULT_INDEX_BY;
-        this.indexByArr = Array.isArray(this.indexBy)
-            ? this.indexBy
-            : [this.indexBy];
-        this.indexByResolver =
-            typeof this.indexBy === "string"
-                ? (obj) => obj[this.indexBy]
-                : (obj) => types.extractFieldValue(obj, this.indexBy);
-        this._valueEncoding = BORSH_ENCODING(this.type);
+        const transformOptions = properties.transform;
+        this.transformer = transformOptions
+            ? isTransformerWithFunction(transformOptions)
+                ? (obj, context) => transformOptions.transform(obj, context)
+                : transformOptions.type
+                    ? (obj, context) => new transformOptions.type(obj, context)
+                    : (obj) => obj
+            : (obj) => obj; // TODO types
+        const maybeArr = properties.indexBy || DEFAULT_INDEX_BY;
+        this.indexBy = Array.isArray(maybeArr) ? maybeArr : [maybeArr];
+        this.indexByResolver = (obj) => indexerTypes.extractFieldValue(obj, this.indexBy);
+        this._valueEncoding = BORSH_ENCODING(this.documentType);
         if (this._isProgramValues) {
             this._resolverProgramCache = new Map();
         }
-        this._resolverCache = new Cache({ max: 1000 }); // TODO choose limit better (adaptive)
-        this.engine = properties.engine || new HashmapIndexEngine();
-        await this.engine.init({
-            indexBy: this.indexBy,
-            nested: {
-                match: (obj) => obj instanceof this.dbType,
-                query: async (obj, query) => obj.index.search(query)
-            },
-            maxBatchSize: MAX_BATCH_SIZE
-        });
-        await this.engine.start?.();
+        this._resolverCache = new Cache({ max: 10 }); // TODO choose limit better (adaptive)
+        this.index =
+            (await (await this.node.indexer.scope(sha256Base64Sync(concat([this._log.log.id, fromString("/document-index")])))).init({
+                indexBy: this.indexBy,
+                schema: this.wrappedIndexedType,
+                nested: {
+                    match: (obj) => obj instanceof this.dbType,
+                    query: async (obj, query) => obj.index.search(query),
+                },
+                /* maxBatchSize: MAX_BATCH_SIZE */
+            })) || new HashmapIndex();
         await this._query.open({
             topic: sha256Base64Sync(concat([this._log.log.id, fromString("/document")])),
             responseHandler: async (query, ctx) => {
@@ -185,45 +215,53 @@ let DocumentIndex = class DocumentIndex extends Program {
                     return;
                 }
                 if (properties.canSearch &&
-                    (query instanceof types.SearchRequest ||
-                        query instanceof types.CollectNextRequest) &&
+                    (query instanceof indexerTypes.SearchRequest ||
+                        query instanceof indexerTypes.CollectNextRequest) &&
                     !(await properties.canSearch(query, ctx.from))) {
                     return new types.NoAccess();
                 }
-                if (query instanceof types.CloseIteratorRequest) {
+                if (query instanceof indexerTypes.CloseIteratorRequest) {
                     this.processCloseIteratorRequest(query, ctx.from);
                 }
                 else {
-                    const results = await this.processQuery(query, ctx.from, {
-                        canRead: properties.canRead
+                    const results = await this.processQuery(query, ctx.from, false, {
+                        canRead: properties.canRead,
                     });
                     return new types.Results({
                         // Even if results might have length 0, respond, because then we now at least there are no matching results
                         results: results.results,
-                        kept: results.kept
+                        kept: results.kept,
                     });
                 }
             },
             responseType: types.AbstractSearchResult,
-            queryType: types.AbstractSearchRequest
+            queryType: indexerTypes.AbstractSearchRequest,
         });
     }
+    getPending(cursorId) {
+        const queue = this._resultQueue.get(cursorId);
+        if (queue) {
+            return queue.queue.length + queue.keptInIndex;
+        }
+        return this.index.getPending(cursorId);
+    }
     async close(from) {
         const closed = await super.close(from);
         if (closed) {
-            await this.engine.stop?.();
+            await this.index.stop?.();
         }
         return closed;
     }
     async drop(from) {
-        const closed = await super.drop(from);
-        if (closed) {
-            await this.engine.stop?.();
+        const dropped = await super.drop(from);
+        if (dropped) {
+            await this.index.drop?.();
+            await this.index.stop?.();
         }
-        return closed;
+        return dropped;
     }
     async get(key, options) {
-        return (await this.getDetailed(key instanceof types.IdKey ? key : types.toId(key), options))?.[0]?.results[0]?.value;
+        return (await this.getDetailed(key instanceof indexerTypes.IdKey ? key : indexerTypes.toId(key), options))?.[0]?.results[0]?.value;
     }
     async put(value, entry, id) {
         const idString = id.primitive;
@@ -233,73 +271,78 @@ let DocumentIndex = class DocumentIndex extends Program {
         else {
             this._resolverCache.add(idString, value);
         }
+        const existing = await this.index.get(id);
         const context = new types.Context({
-            created: (await this.engine.get(id))?.context.created ||
+            created: existing?.value.__context.created ||
                 entry.meta.clock.timestamp.wallTime,
             modified: entry.meta.clock.timestamp.wallTime,
             head: entry.hash,
-            gid: entry.gid
-        });
-        const valueToIndex = await this.fields(value, context);
-        this.engine.put({
-            id,
-            indexed: valueToIndex,
-            context,
-            size: entry.payload.data.byteLength
-            /* reference:
-                valueToIndex === value || value instanceof Program
-                    ? { value }
-                    : undefined */
+            gid: entry.gid,
+            size: entry.payloadByteLength,
         });
+        const valueToIndex = await this.transformer(value, context);
+        const wrappedValueToIndex = new this.wrappedIndexedType(valueToIndex, context);
+        await this.index.put(wrappedValueToIndex);
     }
     del(key) {
-        const keyObject = types.toId(key);
         if (this._isProgramValues) {
-            this._resolverProgramCache.delete(key);
+            this._resolverProgramCache.delete(key.primitive);
         }
         else {
-            this._resolverCache.del(key);
+            this._resolverCache.del(key.primitive);
         }
-        return this.engine.del(keyObject);
+        return this.index.del(new indexerTypes.DeleteRequest({
+            query: [indexerTypes.getMatcher(this.indexBy, key.key)],
+        }));
     }
     async getDetailed(key, options) {
         let results;
         if (key instanceof Uint8Array) {
-            results = await this.queryDetailed(new types.SearchRequest({
+            results = await this.queryDetailed(new indexerTypes.SearchRequest({
                 query: [
-                    new types.ByteMatchQuery({ key: this.indexByArr, value: key })
-                ]
+                    new indexerTypes.ByteMatchQuery({ key: this.indexBy, value: key }),
+                ],
             }), options);
         }
         else {
-            const indexableKey = types.toIdeable(key);
+            const indexableKey = indexerTypes.toIdeable(key);
             if (typeof indexableKey === "number" ||
                 typeof indexableKey === "bigint") {
-                results = await this.queryDetailed(new types.SearchRequest({
+                results = await this.queryDetailed(new indexerTypes.SearchRequest({
                     query: [
-                        new types.IntegerCompare({
-                            key: this.indexByArr,
-                            compare: types.Compare.Equal,
-                            value: indexableKey
-                        })
-                    ]
+                        new indexerTypes.IntegerCompare({
+                            key: this.indexBy,
+                            compare: indexerTypes.Compare.Equal,
+                            value: indexableKey,
+                        }),
+                    ],
                 }), options);
             }
-            else {
-                results = await this.queryDetailed(new types.SearchRequest({
+            else if (typeof indexableKey === "string") {
+                results = await this.queryDetailed(new indexerTypes.SearchRequest({
                     query: [
-                        new types.StringMatch({
-                            key: this.indexByArr,
-                            value: indexableKey
-                        })
-                    ]
+                        new indexerTypes.StringMatch({
+                            key: this.indexBy,
+                            value: indexableKey,
+                        }),
+                    ],
+                }), options);
+            }
+            else if (indexableKey instanceof Uint8Array) {
+                results = await this.queryDetailed(new indexerTypes.SearchRequest({
+                    query: [
+                        new indexerTypes.ByteMatchQuery({
+                            key: this.indexBy,
+                            value: indexableKey,
+                        }),
+                    ],
                 }), options);
             }
         }
         return results;
     }
     getSize() {
-        return this.engine.getSize();
+        return this.index.getSize();
     }
     async resolveDocument(value) {
         const cached = this._resolverCache.get(value.id.primitive) ||
@@ -307,10 +350,13 @@ let DocumentIndex = class DocumentIndex extends Program {
         if (cached != null) {
             return { value: cached };
         }
-        if (value.indexed instanceof this.type) {
-            return { value: value.indexed };
+        if (this.indexedTypeIsDocumentType) {
+            // cast value to T, i.e. convert the class but keep all properties except the __context
+            const obj = Object.assign(Object.create(this.documentType.prototype), value.value);
+            delete obj.__context;
+            return { value: obj };
         }
-        const head = await await this._log.log.get(value.context.head);
+        const head = await this._log.log.get(value.value.__context.head);
         if (!head) {
             return undefined; // we could end up here if we recently pruned the document and other peers never persisted the entry
             // TODO update changes in index before removing entries from log entry storage
@@ -318,47 +364,98 @@ let DocumentIndex = class DocumentIndex extends Program {
         const payloadValue = await head.getPayloadValue();
         if (payloadValue instanceof PutOperation) {
             return {
-                value: this.valueEncoding.decoder(payloadValue.data)
+                value: this.valueEncoding.decoder(payloadValue.data),
                 /* size: payloadValue.data.byteLength */
             };
         }
         throw new Error("Unexpected value type when getting document: " +
             payloadValue?.constructor?.name || typeof payloadValue);
     }
-    async processQuery(query, from, options) {
+    async processQuery(query, from, isLocal, options) {
         // We do special case for querying the id as we can do it faster than iterating
+        let prevQueued = isLocal
+            ? undefined
+            : this._resultQueue.get(query.idString);
+        if (prevQueued && !from.equals(prevQueued.from)) {
+            throw new Error("Different from in queued results");
+        }
         let indexedResult = undefined;
-        if (query instanceof types.SearchRequest) {
-            indexedResult = await this.engine.query(query, from);
+        if (query instanceof indexerTypes.SearchRequest) {
+            indexedResult = await this.index.query(query);
         }
-        else if (query instanceof types.CollectNextRequest) {
-            indexedResult = await this.engine.next(query, from);
+        else if (query instanceof indexerTypes.CollectNextRequest) {
+            indexedResult =
+                prevQueued?.keptInIndex === 0
+                    ? { kept: 0, results: [] }
+                    : await this.index.next(query);
         }
         else {
             throw new Error("Unsupported");
         }
         const filteredResults = [];
-        for (const result of indexedResult.results) {
+        let resultSize = 0;
+        let toIterate = prevQueued
+            ? [...prevQueued.queue, ...indexedResult.results]
+            : indexedResult.results;
+        if (prevQueued) {
+            this._resultQueue.delete(query.idString);
+            prevQueued = undefined;
+        }
+        if (!isLocal) {
+            prevQueued = {
+                from,
+                queue: [],
+                timeout: setTimeout(() => {
+                    this._resultQueue.delete(query.idString);
+                }, 6e4),
+                keptInIndex: indexedResult.kept,
+            };
+            this._resultQueue.set(query.idString, prevQueued);
+        }
+        for (const result of toIterate) {
+            if (!isLocal) {
+                resultSize += result.value.__context.size;
+                if (resultSize > MAX_BATCH_SIZE) {
+                    prevQueued.queue.push(result);
+                    continue;
+                }
+            }
             const value = await this.resolveDocument(result);
             if (!value ||
                 (options?.canRead && !(await options.canRead(value.value, from)))) {
                 continue;
             }
             filteredResults.push(new types.ResultWithSource({
-                context: result.context,
+                context: result.value.__context,
                 value: value.value,
                 source: serialize(value.value),
-                indexed: result.indexed
+                indexed: result.value,
             }));
         }
         const results = new types.Results({
             results: filteredResults,
-            kept: BigInt(indexedResult.kept)
+            kept: BigInt(indexedResult.kept + (prevQueued?.queue.length || 0)),
         });
+        if (!isLocal && results.kept === 0n) {
+            this.clearResultsQueue(query);
+        }
         return results;
     }
+    clearResultsQueue(query) {
+        const queue = this._resultQueue.get(query.idString);
+        if (queue) {
+            clearTimeout(queue.timeout);
+            this._resultQueue.delete(query.idString);
+        }
+    }
     async processCloseIteratorRequest(query, publicKey) {
-        return this.engine.close(query, publicKey);
+        const queueData = this._resultQueue.get(query.idString);
+        if (queueData && !queueData.from.equals(publicKey)) {
+            logger.info("Ignoring close iterator request from different peer");
+            return;
+        }
+        this.clearResultsQueue(query);
+        return this.index.close(query);
     }
     /**
      * Query and retrieve results with most details
@@ -367,7 +464,7 @@ let DocumentIndex = class DocumentIndex extends Program {
      * @returns
      */
     async queryDetailed(queryRequest, options) {
-        const local = typeof options?.local == "boolean" ? options?.local : true;
+        const local = typeof options?.local === "boolean" ? options?.local : true;
         let remote = undefined;
         if (typeof options?.remote === "boolean") {
             if (options?.remote) {
@@ -392,7 +489,7 @@ let DocumentIndex = class DocumentIndex extends Program {
         }
         const allResults = [];
         if (local) {
-            const results = await this.processQuery(queryRequest, this.node.identity.publicKey);
+            const results = await this.processQuery(queryRequest, this.node.identity.publicKey, true);
             if (results.results.length > 0) {
                 options?.onResponse &&
                     (await options.onResponse(results, this.node.identity.publicKey));
@@ -406,12 +503,12 @@ let DocumentIndex = class DocumentIndex extends Program {
                 const fn = async () => {
                     const rs = [];
                     const responseHandler = async (results) => {
-                        for (const r of await introduceEntries(results, this.type, this._sync, options)) {
+                        for (const r of await introduceEntries(results, this.documentType, this._sync, options)) {
                             rs.push(r.response);
                         }
                     };
                     try {
-                        if (queryRequest instanceof types.CloseIteratorRequest) {
+                        if (queryRequest instanceof indexerTypes.CloseIteratorRequest) {
                             // don't wait for responses
                             await this._query.request(queryRequest, { mode: remote.mode });
                         }
@@ -467,7 +564,7 @@ let DocumentIndex = class DocumentIndex extends Program {
      */
     async search(queryRequest, options) {
         // Set fetch to search size, or max value (default to max u32 (4294967295))
-        queryRequest.fetch = options?.size ?? 0xffffffff;
+        queryRequest.fetch = queryRequest.fetch ?? 0xffffffff;
         // So that the iterator is pre-fetching the right amount of entries
         const iterator = this.iterate(queryRequest, options);
         // So that this call will not do any remote requests
@@ -524,7 +621,7 @@ let DocumentIndex = class DocumentIndex extends Program {
                         }
                         const buffer = [];
                         for (const result of results.results) {
-                            const indexKey = types.toIdeable(this.indexByResolver(result.value));
+                            const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
                             if (visited.has(indexKey)) {
                                 continue;
                             }
@@ -532,21 +629,24 @@ let DocumentIndex = class DocumentIndex extends Program {
                             buffer.push({
                                 value: result.value,
                                 context: result.context,
-                                from: from,
+                                from,
                                 indexed: result.indexed ||
-                                    (await this.fields(result.value, result.context))
+                                    (await this.transformer(result.value, result.context)),
                             });
                         }
                         peerBufferMap.set(from.hashcode(), {
                             buffer,
-                            kept: Number(response.kept)
+                            kept: Number(response.kept),
                         });
                     }
                     else {
                         throw new Error("Unsupported result type: " + response?.constructor?.name);
                     }
-                }
+                },
             });
+            if (done) {
+                this.clearResultsQueue(queryRequest);
+            }
             return done;
         };
         const fetchAtLeast = async (n) => {
@@ -571,13 +671,13 @@ let DocumentIndex = class DocumentIndex extends Program {
                     }
                     // TODO buffer more than deleted?
                     // TODO batch to multiple 'to's
-                    const collectRequest = new types.CollectNextRequest({
+                    const collectRequest = new indexerTypes.CollectNextRequest({
                         id: queryRequest.id,
-                        amount: n - buffer.buffer.length
+                        amount: n - buffer.buffer.length,
                     });
                     // Fetch locally?
                     if (peer === this.node.identity.publicKey.hashcode()) {
-                        promises.push(this.processQuery(collectRequest, this.node.identity.publicKey)
+                        promises.push(this.processQuery(collectRequest, this.node.identity.publicKey, true)
                             .then(async (results) => {
                             resultsLeft += Number(results.kept);
                             if (results.results.length === 0) {
@@ -592,16 +692,18 @@ let DocumentIndex = class DocumentIndex extends Program {
                                 }
                                 peerBuffer.kept = Number(results.kept);
                                 for (const result of results.results) {
-                                    if (visited.has(types.toIdeable(this.indexByResolver(result.value)))) {
+                                    if (visited.has(indexerTypes.toId(this.indexByResolver(result.value))
+                                        .primitive)) {
                                         continue;
                                     }
-                                    visited.add(types.toIdeable(this.indexByResolver(result.value)));
+                                    visited.add(indexerTypes.toId(this.indexByResolver(result.value))
+                                        .primitive);
                                     peerBuffer.buffer.push({
                                         value: result.value,
                                         context: result.context,
                                         from: this.node.identity.publicKey,
                                         indexed: result.indexed ||
-                                            (await this.fields(result.value, result.context))
+                                            (await this.transformer(result.value, result.context)),
                                     });
                                 }
                             }
@@ -618,9 +720,9 @@ let DocumentIndex = class DocumentIndex extends Program {
                             ...options,
                             signal: controller.signal,
                             priority: 1,
-                            mode: new SilentDelivery({ to: [peer], redundancy: 1 })
+                            mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
                         })
-                            .then((response) => introduceEntries(response, this.type, this._sync, options)
+                            .then((response) => introduceEntries(response, this.documentType, this._sync, options)
                             .then((responses) => {
                             responses.map((response) => {
                                 resultsLeft += Number(response.response.kept);
@@ -640,15 +742,15 @@ let DocumentIndex = class DocumentIndex extends Program {
                                     }
                                     peerBuffer.kept = Number(response.response.kept);
                                     for (const result of response.response.results) {
-                                        if (visited.has(types.toIdeable(this.indexByResolver(result.value)))) {
+                                        if (visited.has(indexerTypes.toId(this.indexByResolver(result.value)).primitive)) {
                                             continue;
                                         }
-                                        visited.add(types.toIdeable(this.indexByResolver(result.value)));
+                                        visited.add(indexerTypes.toId(this.indexByResolver(result.value)).primitive);
                                         peerBuffer.buffer.push({
                                             value: result.value,
                                             context: result.context,
                                             from: response.from,
-                                            indexed: this.fields(result.value, result.context)
+                                            indexed: this.transformer(result.value, result.context),
                                         });
                                     }
                                 }
@@ -681,7 +783,8 @@ let DocumentIndex = class DocumentIndex extends Program {
             // TODO everything below is not very optimized
             const fetchedAll = await fetchAtLeast(n);
             // get n next top entries, shift and pull more results
-            const results = await types.resolvedSort(peerBuffers(), queryRequest.sort);
+            const peerBuffersArr = peerBuffers();
+            const results = peerBuffersArr.sort((a, b) => indexerTypes.extractSortCompare(a.indexed, b.indexed, queryRequest.sort));
             const pendingMoreResults = n < results.length;
             const batch = results.splice(0, n);
             for (const result of batch) {
@@ -690,7 +793,7 @@ let DocumentIndex = class DocumentIndex extends Program {
                     logger.error("Unexpected empty result buffer");
                     continue;
                 }
-                const idx = arr.buffer.findIndex((x) => x.value == result.value);
+                const idx = arr.buffer.findIndex((x) => x.value === result.value);
                 if (idx >= 0) {
                     arr.buffer.splice(idx, 1);
                 }
@@ -700,8 +803,8 @@ let DocumentIndex = class DocumentIndex extends Program {
         };
         const close = async () => {
             controller.abort(new AbortError("Iterator closed"));
-            const closeRequest = new types.CloseIteratorRequest({
-                id: queryRequest.id
+            const closeRequest = new indexerTypes.CloseIteratorRequest({
+                id: queryRequest.id,
             });
             const promises = [];
             for (const [peer, buffer] of peerBufferMap) {
@@ -717,7 +820,7 @@ let DocumentIndex = class DocumentIndex extends Program {
                     // Close remote
                     promises.push(this._query.send(closeRequest, {
                         ...options,
-                        mode: new SilentDelivery({ to: [peer], redundancy: 1 })
+                        mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
                     }));
                 }
             }
@@ -726,7 +829,7 @@ let DocumentIndex = class DocumentIndex extends Program {
         return {
             close,
             next,
-            done: () => done
+            done: () => done,
         };
     }
 };