@peerbit/indexer-tests 1.0.4 → 1.1.0

package/dist/src/tests.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { deserialize, field, fixedArray, option, serialize, variant, vec, } from "@dao-xyz/borsh";
 import { randomBytes } from "@peerbit/crypto";
-import { And, BoolQuery, ByteMatchQuery, Compare, CountRequest, DeleteRequest, IntegerCompare, IsNull, Nested, Not, Or, Query, SearchRequest, Sort, SortDirection, StringMatch, StringMatchMethod, SumRequest, extractFieldValue, getIdProperty, id, iterate, toId, } from "@peerbit/indexer-interface";
+import { And, BoolQuery, ByteMatchQuery, Compare, IntegerCompare, IsNull, Nested, Not, Or, Query, Sort, SortDirection, StringMatch, StringMatchMethod, extractFieldValue, getIdProperty, id, toId, } from "@peerbit/indexer-interface";
 import { 
 /* delay,  */
 delay, waitForResolved, } from "@peerbit/time";
@@ -127,8 +127,14 @@ DocumentNext = __decorate([
 const bigIntSort = (a, b) => a > b ? 1 : 0 || -(a < b);
 const search = (index, query, options) => {
     // fetch max u32
-    query.fetch = 0xffffffff;
-    return index.query(query, options);
+    return index.iterate(query, options).all();
+};
+const assertIteratorIsDone = async (iterator) => {
+    const next = await iterator.next(1);
+    if (next.length > 0) {
+        throw new Error(`Iterator is not done, got more results`);
+    }
+    expect(iterator.done()).to.be.true;
 };
 export const tests = (createIndicies, type = "transient", shapingSupported) => {
     return describe("index", () => {
@@ -263,9 +269,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         current[path] = docId;
                     }
                 }
-                await store.del(new DeleteRequest({
+                await store.del({
                     query: deleteQueryObject,
-                }));
+                });
                 expect(await store.getSize()).equal(0);
                 result = await store.get(toId(docId));
                 expect(result).equal(undefined);
@@ -337,7 +343,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         value: "Hello world",
                     });
                     await store.put(doc);
-                    const results = await search(store, new SearchRequest({
+                    const results = await search(store, {
                         query: [
                             new StringMatch({
                                 key: "id",
@@ -346,8 +352,8 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                 method: StringMatchMethod.contains,
                             }),
                         ],
-                    }));
-                    expect(results.results).to.have.length(1);
+                    });
+                    expect(results).to.have.length(1);
                 });
             });
             describe("bytes", () => {
@@ -508,9 +514,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
             describe("fields", () => {
                 it("no-args", async () => {
                     await setupDefault();
-                    const results = await search(store, new SearchRequest({ query: [] }));
-                    expect(results.results).to.have.length(4);
-                    for (const result of results.results) {
+                    const results = await search(store, { query: [] });
+                    expect(results).to.have.length(4);
+                    for (const result of results) {
                         checkDocument(result.value, ...defaultDocs);
                     }
                 });
@@ -519,7 +525,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         await setupDefault();
                     });
                     it("exact", async () => {
-                        const responses = await search(store, new SearchRequest({
+                        const responses = await search(store, {
                             query: [
                                 new StringMatch({
                                     key: "name",
@@ -527,11 +533,14 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     caseInsensitive: true,
                                 }),
                             ],
-                        }));
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1", "2"]);
+                        });
+                        expect(responses.map((x) => x.id.primitive)).to.have.members([
+                            "1",
+                            "2",
+                        ]);
                     });
                     it("exact-case-insensitive", async () => {
-                        const responses = await search(store, new SearchRequest({
+                        const responses = await search(store, {
                             query: [
                                 new StringMatch({
                                     key: "name",
@@ -539,12 +548,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     caseInsensitive: true,
                                 }),
                             ],
-                        }));
-                        expect(responses.results).to.have.length(2);
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1", "2"]);
+                        });
+                        expect(responses).to.have.length(2);
+                        expect(responses.map((x) => x.id.primitive)).to.have.members([
+                            "1",
+                            "2",
+                        ]);
                     });
                     it("exact case sensitive", async () => {
-                        let responses = await search(store, new SearchRequest({
+                        let responses = await search(store, {
                             query: [
                                 new StringMatch({
                                     key: "name",
@@ -552,10 +564,10 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     caseInsensitive: false,
                                 }),
                             ],
-                        }));
-                        expect(responses.results).to.have.length(1);
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["2"]);
-                        responses = await search(store, new SearchRequest({
+                        });
+                        expect(responses).to.have.length(1);
+                        expect(responses.map((x) => x.id.primitive)).to.have.members(["2"]);
+                        responses = await search(store, {
                             query: [
                                 new StringMatch({
                                     key: "name",
@@ -563,11 +575,11 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     caseInsensitive: false,
                                 }),
                             ],
-                        }));
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1"]);
+                        });
+                        expect(responses.map((x) => x.id.primitive)).to.have.members(["1"]);
                     });
                     it("prefix", async () => {
-                        const responses = await search(store, new SearchRequest({
+                        const responses = await search(store, {
                             query: [
                                 new StringMatch({
                                     key: "name",
@@ -576,12 +588,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     caseInsensitive: true,
                                 }),
                             ],
-                        }));
-                        expect(responses.results).to.have.length(2);
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1", "2"]);
+                        });
+                        expect(responses).to.have.length(2);
+                        expect(responses.map((x) => x.id.primitive)).to.have.members([
+                            "1",
+                            "2",
+                        ]);
                     });
                     it("contains", async () => {
-                        const responses = await search(store, new SearchRequest({
+                        const responses = await search(store, {
                             query: [
                                 new StringMatch({
                                     key: "name",
@@ -590,13 +605,16 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     caseInsensitive: true,
                                 }),
                             ],
-                        }));
-                        expect(responses.results).to.have.length(2);
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1", "2"]);
+                        });
+                        expect(responses).to.have.length(2);
+                        expect(responses.map((x) => x.id.primitive)).to.have.members([
+                            "1",
+                            "2",
+                        ]);
                     });
                     describe("arr", () => {
                         it("arr", async () => {
-                            const responses = await search(store, new SearchRequest({
+                            const responses = await search(store, {
                                 query: [
                                     new StringMatch({
                                         key: "tags",
@@ -605,60 +623,62 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                         caseInsensitive: true,
                                     }),
                                 ],
-                            }));
-                            expect(responses.results).to.have.length(1);
-                            expect(responses.results.map((x) => x.id.primitive)).to.have.members(["2"]);
-                            checkDocument(responses.results[0].value, ...defaultDocs);
+                            });
+                            expect(responses).to.have.length(1);
+                            expect(responses.map((x) => x.id.primitive)).to.have.members([
+                                "2",
+                            ]);
+                            checkDocument(responses[0].value, ...defaultDocs);
                         });
                     });
                 });
                 it("missing", async () => {
                     await setupDefault();
-                    const responses = await search(store, new SearchRequest({
+                    const responses = await search(store, {
                         query: [
                             new IsNull({
                                 key: "name",
                             }),
                         ],
-                    }));
-                    expect(responses.results).to.have.length(1);
-                    expect(responses.results.map((x) => x.id.primitive)).to.deep.equal([
-                        "4",
-                    ]);
+                    });
+                    expect(responses).to.have.length(1);
+                    expect(responses.map((x) => x.id.primitive)).to.deep.equal(["4"]);
                 });
                 describe("uint8arrays", () => {
                     describe("dynamic", () => {
                         describe("bytematch", () => {
                             it("matches", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new ByteMatchQuery({
                                             key: "data",
                                             value: new Uint8Array([1]),
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.have.length(1);
-                                expect(responses.results.map((x) => x.id.primitive)).to.deep.equal(["1"]);
+                                });
+                                expect(responses).to.have.length(1);
+                                expect(responses.map((x) => x.id.primitive)).to.deep.equal([
+                                    "1",
+                                ]);
                             });
                             it("un-matches", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new ByteMatchQuery({
                                             key: "data",
                                             value: new Uint8Array([199]),
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.be.empty;
+                                });
+                                expect(responses).to.be.empty;
                             });
                         });
                         describe("integer", () => {
                             it("exists", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new IntegerCompare({
                                             key: "data",
@@ -666,13 +686,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                             value: 1,
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.have.length(1);
-                                expect(responses.results.map((x) => x.id.primitive)).to.deep.equal(["1"]);
+                                });
+                                expect(responses).to.have.length(1);
+                                expect(responses.map((x) => x.id.primitive)).to.deep.equal([
+                                    "1",
+                                ]);
                             });
                             it("does not exist", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new IntegerCompare({
                                             key: "data",
@@ -680,8 +702,8 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                             value: 199,
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.be.empty;
+                                });
+                                expect(responses).to.be.empty;
                             });
                         });
                     });
@@ -689,34 +711,36 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         describe("bytematch", () => {
                             it("matches", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new ByteMatchQuery({
                                             key: "fixedData",
                                             value: new Uint8Array(32).fill(1),
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.have.length(1);
-                                expect(responses.results.map((x) => x.id.primitive)).to.deep.equal(["1"]);
+                                });
+                                expect(responses).to.have.length(1);
+                                expect(responses.map((x) => x.id.primitive)).to.deep.equal([
+                                    "1",
+                                ]);
                             });
                             it("un-matches", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new ByteMatchQuery({
                                             key: "data",
                                             value: new Uint8Array(32).fill(99),
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.be.empty;
+                                });
+                                expect(responses).to.be.empty;
                             });
                         });
                         describe("integer", () => {
                             it("exists", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new IntegerCompare({
                                             key: "data",
@@ -724,13 +748,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                             value: 1,
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.have.length(1);
-                                expect(responses.results.map((x) => x.id.primitive)).to.deep.equal(["1"]);
+                                });
+                                expect(responses).to.have.length(1);
+                                expect(responses.map((x) => x.id.primitive)).to.deep.equal([
+                                    "1",
+                                ]);
                             });
                             it("does not exist", async () => {
                                 await setupDefault();
-                                const responses = await search(store, new SearchRequest({
+                                const responses = await search(store, {
                                     query: [
                                         new IntegerCompare({
                                             key: "data",
@@ -738,26 +764,24 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                             value: 199,
                                         }),
                                     ],
-                                }));
-                                expect(responses.results).to.be.empty;
+                                });
+                                expect(responses).to.be.empty;
                             });
                         });
                     });
                 });
                 +it("bool", async () => {
                     await setupDefault();
-                    const responses = await search(store, new SearchRequest({
+                    const responses = await search(store, {
                         query: [
                             new BoolQuery({
                                 key: "bool",
                                 value: true,
                             }),
                         ],
-                    }));
-                    expect(responses.results).to.have.length(1);
-                    expect(responses.results.map((x) => x.id.primitive)).to.deep.equal([
-                        "1",
-                    ]);
+                    });
+                    expect(responses).to.have.length(1);
+                    expect(responses.map((x) => x.id.primitive)).to.deep.equal(["1"]);
                 });
                 describe("array", () => {
                     describe("uint8arrays", () => {
@@ -787,17 +811,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             await store.put(new Uint8arraysVec({
                                 bytesArrays: [new Uint8Array([3])],
                             }));
-                            const results = await search(store, new SearchRequest({
+                            const results = await search(store, {
                                 query: [
                                     new ByteMatchQuery({
                                         key: "bytesArrays",
                                         value: new Uint8Array([2]),
                                     }),
                                 ],
-                            }));
-                            expect(results.results.map((x) => x.value.id)).to.deep.equal([
-                                d1.id,
-                            ]);
+                            });
+                            expect(results.map((x) => x.value.id)).to.deep.equal([d1.id]);
                         });
                     });
                     describe("documents", () => {
@@ -831,16 +853,14 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     new Document({ id: uuid(), number: 124n, tags: [] }),
                                 ],
                             }));
-                            const results = await search(store, new SearchRequest({
+                            const results = await search(store, {
                                 query: new IntegerCompare({
                                     key: ["documents", "number"],
                                     compare: Compare.Equal,
                                     value: d1.documents[0].number,
                                 }),
-                            }));
-                            expect(results.results.map((x) => x.value.id)).to.deep.equal([
-                                d1.id,
-                            ]);
+                            });
+                            expect(results.map((x) => x.value.id)).to.deep.equal([d1.id]);
                         });
                         it("update array", async () => {
                             const out = await setup({ schema: DocumentsVec });
@@ -856,20 +876,20 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             ];
                             await store.put(d1);
                             // should have update results
-                            expect((await search(store, new SearchRequest({
+                            expect((await search(store, {
                                 query: new IntegerCompare({
                                     key: ["documents", "number"],
                                     compare: Compare.Equal,
                                     value: 123n,
                                 }),
-                            }))).results.length).to.equal(0);
-                            expect((await search(store, new SearchRequest({
+                            })).length).to.equal(0);
+                            expect((await search(store, {
                                 query: new IntegerCompare({
                                     key: ["documents", "number"],
                                     compare: Compare.Equal,
                                     value: 124n,
                                 }),
-                            }))).results.map((x) => x.value.id)).to.deep.equal([d1.id]);
+                            })).map((x) => x.value.id)).to.deep.equal([d1.id]);
                         });
                         it("put delete put", async () => {
                             const { store } = await setup({ schema: DocumentsVec });
@@ -879,37 +899,37 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                 ],
                             });
                             await store.put(d1);
-                            const [deleted] = await store.del(new DeleteRequest({
+                            const [deleted] = await store.del({
                                 query: {
                                     id: d1.id,
                                 },
-                            }));
+                            });
                             expect(deleted.key).to.deep.equal(d1.id);
-                            expect((await search(store, new SearchRequest({
+                            expect((await search(store, {
                                 query: new IntegerCompare({
                                     key: ["documents", "number"],
                                     compare: Compare.Equal,
                                     value: 123n,
                                 }),
-                            }))).results.length).to.equal(0);
+                            })).length).to.equal(0);
                             d1.documents = [
                                 new Document({ id: uuid(), number: 124n, tags: [] }),
                             ];
                             await store.put(d1);
-                            expect((await search(store, new SearchRequest({
+                            expect((await search(store, {
                                 query: new IntegerCompare({
                                     key: ["documents", "number"],
                                     compare: Compare.Equal,
                                     value: 124n,
                                 }),
-                            }))).results.map((x) => x.value.id)).to.deep.equal([d1.id]);
-                            expect((await search(store, new SearchRequest({
+                            })).map((x) => x.value.id)).to.deep.equal([d1.id]);
+                            expect((await search(store, {
                                 query: new IntegerCompare({
                                     key: ["documents", "number"],
                                     compare: Compare.Equal,
                                     value: 123n,
                                 }),
-                            }))).results.length).to.equal(0);
+                            })).length).to.equal(0);
                         });
                     });
                 });
@@ -918,7 +938,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         await setupDefault();
                     });
                     it("and", async () => {
-                        const responses = await search(store, new SearchRequest({
+                        const responses = await search(store, {
                             query: [
                                 new And([
                                     new StringMatch({
@@ -935,12 +955,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     }),
                                 ]),
                             ],
-                        }));
-                        expect(responses.results).to.have.length(2);
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1", "2"]);
+                        });
+                        expect(responses).to.have.length(2);
+                        expect(responses.map((x) => x.id.primitive)).to.have.members([
+                            "1",
+                            "2",
+                        ]);
                     });
                     it("or", async () => {
-                        const responses = await search(store, new SearchRequest({
+                        const responses = await search(store, {
                             query: [
                                 new Or([
                                     new StringMatch({
@@ -953,12 +976,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     }),
                                 ]),
                             ],
-                        }));
-                        expect(responses.results).to.have.length(2);
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1", "2"]);
+                        });
+                        expect(responses).to.have.length(2);
+                        expect(responses.map((x) => x.id.primitive)).to.have.members([
+                            "1",
+                            "2",
+                        ]);
                     });
                     it("not", async () => {
-                        const responses = await search(store, new SearchRequest({
+                        const responses = await search(store, {
                             query: [
                                 new And([
                                     new Not(new IntegerCompare({
@@ -968,9 +994,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     })),
                                 ]),
                             ],
-                        }));
-                        expect(responses.results).to.have.length(1);
-                        expect(responses.results.map((x) => x.id.primitive)).to.have.members(["1"]);
+                        });
+                        expect(responses).to.have.length(1);
+                        expect(responses.map((x) => x.id.primitive)).to.have.members(["1"]);
                     });
                 });
                 describe("number", () => {
@@ -978,7 +1004,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         await setupDefault();
                     });
                     it("equal", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "number",
@@ -986,12 +1012,12 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: 2n,
                                 }),
                             ],
-                        }));
-                        expect(response.results).to.have.length(1);
-                        expect(response.results[0].value.number).to.be.oneOf([2n, 2]);
+                        });
+                        expect(response).to.have.length(1);
+                        expect(response[0].value.number).to.be.oneOf([2n, 2]);
                     });
                     it("gt", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "number",
@@ -999,12 +1025,12 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: 2n,
                                 }),
                             ],
-                        }));
-                        expect(response.results).to.have.length(1);
-                        expect(response.results[0].value.number).to.be.oneOf([3n, 3]);
+                        });
+                        expect(response).to.have.length(1);
+                        expect(response[0].value.number).to.be.oneOf([3n, 3]);
                     });
                     it("gte", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "number",
@@ -1012,14 +1038,14 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: 2n,
                                 }),
                             ],
-                        }));
-                        response.results.sort((a, b) => bigIntSort(a.value.number, b.value.number));
-                        expect(response.results).to.have.length(2);
-                        expect(response.results[0].value.number).to.be.oneOf([2n, 2]);
-                        expect(response.results[1].value.number).to.be.oneOf([3n, 3]);
+                        });
+                        response.sort((a, b) => bigIntSort(a.value.number, b.value.number));
+                        expect(response).to.have.length(2);
+                        expect(response[0].value.number).to.be.oneOf([2n, 2]);
+                        expect(response[1].value.number).to.be.oneOf([3n, 3]);
                     });
                     it("lt", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "number",
@@ -1027,12 +1053,12 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: 2n,
                                 }),
                             ],
-                        }));
-                        expect(response.results).to.have.length(1);
-                        expect(response.results[0].value.number).to.be.oneOf([1n, 1]);
+                        });
+                        expect(response).to.have.length(1);
+                        expect(response[0].value.number).to.be.oneOf([1n, 1]);
                     });
                     it("lte", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "number",
@@ -1040,11 +1066,11 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: 2n,
                                 }),
                             ],
-                        }));
-                        response.results.sort((a, b) => bigIntSort(a.value.number, b.value.number));
-                        expect(response.results).to.have.length(2);
-                        expect(response.results[0].value.number).to.be.oneOf([1n, 1]);
-                        expect(response.results[1].value.number).to.be.oneOf([2n, 2]);
+                        });
+                        response.sort((a, b) => bigIntSort(a.value.number, b.value.number));
+                        expect(response).to.have.length(2);
+                        expect(response[0].value.number).to.be.oneOf([1n, 1]);
+                        expect(response[1].value.number).to.be.oneOf([2n, 2]);
                     });
                 });
                 describe("bigint", () => {
@@ -1080,7 +1106,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         expect(ser).to.equal(first);
                     });
                     it("equal", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "bigint",
@@ -1088,12 +1114,12 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: first,
                                 }),
                             ],
-                        }));
-                        expect(response.results).to.have.length(1);
-                        expect(response.results[0].value.bigint).to.equal(first);
+                        });
+                        expect(response).to.have.length(1);
+                        expect(response[0].value.bigint).to.equal(first);
                     });
                     it("gt", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "bigint",
@@ -1101,12 +1127,12 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: second,
                                 }),
                             ],
-                        }));
-                        expect(response.results).to.have.length(1);
-                        expect(response.results[0].value.bigint).to.equal(third);
+                        });
+                        expect(response).to.have.length(1);
+                        expect(response[0].value.bigint).to.equal(third);
                     });
                     it("gte", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "bigint",
@@ -1114,14 +1140,14 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: second,
                                 }),
                             ],
-                        }));
-                        response.results.sort((a, b) => bigIntSort(a.value.bigint, b.value.bigint));
-                        expect(response.results).to.have.length(2);
-                        expect(response.results[0].value.bigint).to.equal(second);
-                        expect(response.results[1].value.bigint).to.equal(third);
+                        });
+                        response.sort((a, b) => bigIntSort(a.value.bigint, b.value.bigint));
+                        expect(response).to.have.length(2);
+                        expect(response[0].value.bigint).to.equal(second);
+                        expect(response[1].value.bigint).to.equal(third);
                     });
                     it("lt", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "bigint",
@@ -1129,12 +1155,12 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: second,
                                 }),
                             ],
-                        }));
-                        expect(response.results).to.have.length(1);
-                        expect(response.results[0].value.bigint).to.equal(first);
+                        });
+                        expect(response).to.have.length(1);
+                        expect(response[0].value.bigint).to.equal(first);
                     });
                     it("lte", async () => {
-                        const response = await search(store, new SearchRequest({
+                        const response = await search(store, {
                             query: [
                                 new IntegerCompare({
                                     key: "bigint",
@@ -1142,11 +1168,11 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     value: second,
                                 }),
                             ],
-                        }));
-                        response.results.sort((a, b) => bigIntSort(a.value.number, b.value.number));
-                        expect(response.results).to.have.length(2);
-                        expect(response.results[0].value.bigint).to.equal(first);
-                        expect(response.results[1].value.bigint).to.equal(second);
+                        });
+                        response.sort((a, b) => bigIntSort(a.value.number, b.value.number));
+                        expect(response).to.have.length(2);
+                        expect(response[0].value.bigint).to.equal(first);
+                        expect(response[1].value.bigint).to.equal(second);
                     });
                 });
                 describe("nested", () => {
@@ -1200,7 +1226,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                 nested: new Nested({ number: 2n, bool: true }),
                             });
                             await store.put(doc2);
-                            const response = await search(store, new SearchRequest({
+                            const response = await search(store, {
                                 query: [
                                     new IntegerCompare({
                                         key: ["nested", "number"],
@@ -1208,10 +1234,10 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                         value: 2n,
                                     }),
                                 ],
-                            }));
-                            expect(response.results).to.have.length(1);
-                            expect(response.results[0].value.id).to.equal("2");
-                            checkDocument(response.results[0].value, doc2);
+                            });
+                            expect(response).to.have.length(1);
+                            expect(response[0].value.id).to.equal("2");
+                            checkDocument(response[0].value, doc2);
                         });
                         it("bool", async () => {
                             const doc1 = new DocumentWithNesting({
@@ -1224,28 +1250,28 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                 nested: new Nested({ number: 2n, bool: true }),
                             });
                             await store.put(doc2);
-                            let response = await search(store, new SearchRequest({
+                            let response = await search(store, {
                                 query: [
                                     new BoolQuery({
                                         key: ["nested", "bool"],
                                         value: true,
                                     }),
                                 ],
-                            }));
-                            expect(response.results).to.have.length(1);
-                            expect(response.results[0].value.id).to.equal("2");
-                            checkDocument(response.results[0].value, doc2);
-                            response = await search(store, new SearchRequest({
+                            });
+                            expect(response).to.have.length(1);
+                            expect(response[0].value.id).to.equal("2");
+                            checkDocument(response[0].value, doc2);
+                            response = await search(store, {
                                 query: [
                                     new BoolQuery({
                                         key: ["nested", "bool"],
                                         value: false,
                                     }),
                                 ],
-                            }));
-                            expect(response.results).to.have.length(1);
-                            expect(response.results[0].value.id).to.equal("1");
-                            checkDocument(response.results[0].value, doc1);
+                            });
+                            expect(response).to.have.length(1);
+                            expect(response[0].value.id).to.equal("1");
+                            checkDocument(response[0].value, doc1);
                         });
                     });
                     describe("one level flat constructor", () => {
@@ -1293,28 +1319,28 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                 nested: new Nested(true),
                             });
                             await store.put(doc2);
-                            let response = await search(store, new SearchRequest({
+                            let response = await search(store, {
                                 query: [
                                     new BoolQuery({
                                         key: ["nested", "bool"],
                                         value: true,
                                     }),
                                 ],
-                            }));
-                            expect(response.results).to.have.length(1);
-                            expect(response.results[0].value.id).to.equal("2");
-                            checkDocument(response.results[0].value, doc2);
-                            response = await search(store, new SearchRequest({
+                            });
+                            expect(response).to.have.length(1);
+                            expect(response[0].value.id).to.equal("2");
+                            checkDocument(response[0].value, doc2);
+                            response = await search(store, {
                                 query: [
                                     new BoolQuery({
                                         key: ["nested", "bool"],
                                         value: false,
                                     }),
                                 ],
-                            }));
-                            expect(response.results).to.have.length(1);
-                            expect(response.results[0].value.id).to.equal("1");
-                            checkDocument(response.results[0].value, doc1);
+                            });
+                            expect(response).to.have.length(1);
+                            expect(response[0].value.id).to.equal("1");
+                            checkDocument(response[0].value, doc1);
                         });
                     });
                     describe("2-level-variants", () => {
@@ -1375,7 +1401,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                 }),
                             });
                             await store.put(doc2);
-                            const response = await search(store, new SearchRequest({
+                            const response = await search(store, {
                                 query: [
                                     new IntegerCompare({
                                         key: ["nested", "nestedAgain", "number"],
@@ -1383,10 +1409,10 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                         value: 2n,
                                     }),
                                 ],
-                            }));
-                            expect(response.results).to.have.length(1);
-                            expect(response.results[0].value.id).to.equal("2");
-                            checkDocument(response.results[0].value, doc2);
+                            });
+                            expect(response).to.have.length(1);
+                            expect(response[0].value.id).to.equal("2");
+                            checkDocument(response[0].value, doc2);
                         });
                     });
                     describe("3-level-variants", () => {
@@ -1461,7 +1487,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                 }),
                             });
                             await store.put(doc2);
-                            const response = await search(store, new SearchRequest({
+                            const response = await search(store, {
                                 query: [
                                     new IntegerCompare({
                                         key: [
@@ -1474,10 +1500,10 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                         value: 2n,
                                     }),
                                 ],
-                            }));
-                            expect(response.results).to.have.length(1);
-                            expect(response.results[0].value.id).to.equal("2");
-                            checkDocument(response.results[0].value, doc2);
+                            });
+                            expect(response).to.have.length(1);
+                            expect(response[0].value.id).to.equal("2");
+                            checkDocument(response[0].value, doc2);
                         });
                     });
                     describe("poly-morphism", () => {
@@ -1551,17 +1577,17 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     }),
                                 });
                                 await store.put(doc2);
-                                const response = await search(store, new SearchRequest({
+                                const response = await search(store, {
                                     query: [
                                         new StringMatch({
                                             key: ["nested", "string"],
                                             value: "hello",
                                         }),
                                     ],
-                                }));
-                                expect(response.results).to.have.length(1);
-                                expect(response.results[0].value.id).to.equal("2");
-                                checkDocument(response.results[0].value, doc2);
+                                });
+                                expect(response).to.have.length(1);
+                                expect(response[0].value.id).to.equal("2");
+                                checkDocument(response[0].value, doc2);
                             });
                         });
                         describe("non-array-nested", () => {
@@ -1648,17 +1674,17 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                     }),
                                 });
                                 await store.put(doc2);
-                                const response = await search(store, new SearchRequest({
+                                const response = await search(store, {
                                     query: [
                                         new StringMatch({
                                             key: ["nested", "nestedAgain", "string"],
                                             value: "hello",
                                         }),
                                     ],
-                                }));
-                                expect(response.results).to.have.length(1);
-                                expect(response.results[0].value.id).to.equal("2");
-                                checkDocument(response.results[0].value, doc2);
+                                });
+                                expect(response).to.have.length(1);
+                                expect(response[0].value.id).to.equal("2");
+                                checkDocument(response[0].value, doc2);
                             });
                         });
                         describe("array", () => {
@@ -1742,17 +1768,17 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                         ],
                                     });
                                     await store.put(doc2);
-                                    const response = await search(store, new SearchRequest({
+                                    const response = await search(store, {
                                         query: [
                                             new StringMatch({
                                                 key: ["array", "string"],
                                                 value: "world",
                                             }),
                                         ],
-                                    }));
-                                    expect(response.results).to.have.length(1);
-                                    expect(response.results[0].value.id).to.equal("2");
-                                    checkDocument(response.results[0].value, doc2);
+                                    });
+                                    expect(response).to.have.length(1);
+                                    expect(response[0].value.id).to.equal("2");
+                                    checkDocument(response[0].value, doc2);
                                 });
                             });
                             describe("polymorphism-variant-base", () => {
@@ -1828,17 +1854,17 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                         }),
                                     });
                                     await store.put(doc2);
-                                    const response = await search(store, new SearchRequest({
+                                    const response = await search(store, {
                                         query: [
                                             new StringMatch({
                                                 key: ["base", "string"],
                                                 value: "world",
                                             }),
                                         ],
-                                    }));
-                                    expect(response.results).to.have.length(1);
-                                    expect(response.results[0].value.id).to.equal("2");
-                                    checkDocument(response.results[0].value, doc2);
+                                    });
+                                    expect(response).to.have.length(1);
+                                    expect(response[0].value.id).to.equal("2");
+                                    checkDocument(response[0].value, doc2);
                                 });
                             });
                             describe("nested-string-array", () => {
@@ -1889,17 +1915,19 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                         }),
                                     });
                                     await store.put(doc2);
-                                    const response = await search(store, new SearchRequest({
+                                    const response = await search(store, {
                                         query: [
                                             new StringMatch({
                                                 key: ["nested", "arr"],
                                                 value: "värld",
                                             }),
                                         ],
-                                    }));
-                                    expect(response.results).to.have.length(1);
-                                    expect(response.results.map((x) => x.value.id)).to.have.members(["2"]);
-                                    checkDocument(response.results[0].value, doc2);
+                                    });
+                                    expect(response).to.have.length(1);
+                                    expect(response.map((x) => x.value.id)).to.have.members([
+                                        "2",
+                                    ]);
+                                    checkDocument(response[0].value, doc2);
                                 });
                             });
                             describe("nested multiple fields", () => {
@@ -1966,7 +1994,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                             }),
                                         ],
                                     }));
-                                    const response = await search(store, new SearchRequest({
+                                    const response = await search(store, {
                                         query: [
                                             new Nested({
                                                 path: "array",
@@ -1982,10 +2010,10 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                                 ]),
                                             }),
                                         ],
-                                    }));
-                                    expect(response.results).to.have.length(1);
-                                    expect(response.results[0].value.id).to.equal("1");
-                                    checkDocument(response.results[0].value, doc1);
+                                    });
+                                    expect(response).to.have.length(1);
+                                    expect(response[0].value.id).to.equal("1");
+                                    checkDocument(response[0].value, doc1);
                                 });
                                 it("nested partial match", async () => {
                                     // query nested without Nested query to match either or
@@ -2012,7 +2040,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                             }),
                                         ],
                                     }));
-                                    const response = await search(store, new SearchRequest({
+                                    const response = await search(store, {
                                         query: [
                                             new StringMatch({
                                                 key: ["array", "a"],
@@ -2023,9 +2051,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                                                 value: "world",
                                             }),
                                         ],
-                                    }));
-                                    expect(response.results).to.have.length(2);
-                                    checkDocument(response.results[0].value, doc1);
+                                    });
+                                    expect(response).to.have.length(2);
+                                    checkDocument(response[0].value, doc1);
                                 });
                             });
                         });
@@ -2037,22 +2065,22 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     });
                     it("can query one of the version", async () => {
                         await store.put(new DocumentNext({ anotherField: "hello" }));
-                        const result = await search(store, new SearchRequest({
+                        const result = await search(store, {
                             query: new StringMatch({ key: "anotherField", value: "hello" }),
-                        }));
-                        expect(result.results).to.have.length(1);
-                        const [doc] = result.results;
+                        });
+                        expect(result).to.have.length(1);
+                        const [doc] = result;
                         expect(doc.value).to.be.instanceOf(DocumentNext);
                     });
                     it("can query multiple versions at once", async () => {
                         let name = uuid();
                         await store.put(new DocumentNext({ name }));
                         await store.put(new DocumentNext({ name }));
-                        const result = await search(store, new SearchRequest({
+                        const result = await search(store, {
                             query: new StringMatch({ key: "name", value: name }),
-                        }));
-                        expect(result.results).to.have.length(2);
-                        for (const doc of result.results) {
+                        });
+                        expect(result).to.have.length(2);
+                        for (const doc of result) {
                             expect(doc.value).to.be.instanceOf(DocumentNext);
                         }
                     });
@@ -2064,9 +2092,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         await setupDefault();
                     });
                     it("filter field", async () => {
-                        const results = await search(store, new SearchRequest({ query: [] }), { shape: { id: true } });
-                        expect(results.results).to.have.length(4);
-                        for (const result of results.results) {
+                        const results = await search(store, { query: [] }, { shape: { id: true } });
+                        expect(results).to.have.length(4);
+                        for (const result of results) {
                             if (shapingSupported) {
                                 expect(Object.keys(result.value)).to.have.length(1);
                                 expect(result.value["id"]).to.exist;
@@ -2078,9 +2106,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         }
                     });
                     it("nested field", async () => {
-                        const results = await search(store, new SearchRequest({ query: [] }), { shape: { nestedVec: { number: true } } });
-                        expect(results.results).to.have.length(4);
-                        for (const value of results.results) {
+                        const results = await search(store, { query: [] }, { shape: { nestedVec: [{ number: true }] } });
+                        expect(results).to.have.length(4);
+                        for (const value of results) {
                             const arr = value.value["nestedVec"];
                             expect(arr).to.be.exist;
                             if (arr.length > 0) {
@@ -2141,22 +2169,27 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         index = await setup({ schema: NestedBoolQueryDocument });
                         await index.store.put(new NestedBoolQueryDocument("1", new MultifieldNested(true, 1, ["1"])));
                         await index.store.put(new NestedBoolQueryDocument("2", new MultifieldNested(false, 2, ["2"])));
-                        const shapedResults = await iterate(index.store, new SearchRequest({
-                            query: new BoolQuery({ key: ["nested", "bool"], value: false }),
-                            fetch: 1,
-                        })).all({ shape: { id: true } });
+                        const shapedResults = await index.store
+                            .iterate({
+                            query: new BoolQuery({
+                                key: ["nested", "bool"],
+                                value: false,
+                            }),
+                        }, { shape: { id: true } })
+                            .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal("2");
                         if (shapingSupported) {
-                            expect(shapedResults[0].value.nested).to.be.undefined;
+                            expect(shapedResults[0].value["nested"]).to.be.undefined;
                         }
                         else {
-                            expect(shapedResults[0].value.nested).to.exist;
+                            expect(shapedResults[0].value["nested"]).to.exist;
                         }
-                        const unshapedResults = await iterate(index.store, new SearchRequest({
+                        const unshapedResults = await index.store
+                            .iterate({
                             query: new BoolQuery({ key: ["nested", "bool"], value: false }),
-                            fetch: 1,
-                        })).all();
+                        })
+                            .all();
                         expect(unshapedResults).to.have.length(1);
                         expect(unshapedResults[0].value.id).to.equal("2");
                         expect(unshapedResults[0].value.nested).to.exist;
@@ -2167,17 +2200,19 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         const d2 = new NestedBoolQueryDocument("2", new MultifieldNested(false, 2, ["2"]));
                         await index.store.put(d1);
                         await index.store.put(d2);
-                        const unshapedResults = await iterate(index.store, new SearchRequest({
+                        const unshapedResults = await index.store
+                            .iterate({
                             query: new StringMatch({ key: ["id"], value: "2" }),
-                            fetch: 1,
-                        })).all();
+                        })
+                            .all();
                         expect(unshapedResults).to.have.length(1);
                         expect(unshapedResults[0].value.id).to.equal(d2.id);
                         expect(unshapedResults[0].value.nested).to.deep.equal(d2.nested);
-                        const shapedResults = await iterate(index.store, new SearchRequest({
+                        const shapedResults = await index.store
+                            .iterate({
                             query: new StringMatch({ key: ["id"], value: "2" }),
-                            fetch: 1,
-                        })).all({ shape: { id: true, nested: { bool: true } } });
+                        }, { shape: { id: true, nested: { bool: true } } })
+                            .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal(d2.id);
                         if (shapingSupported) {
@@ -2271,22 +2306,27 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         index = await setup({ schema: NestedBoolQueryDocument });
                         await index.store.put(new NestedBoolQueryDocument("1", new MultifieldNested(true, 1, ["1"])));
                         await index.store.put(new NestedBoolQueryDocument("2", new MultifieldNested(false, 2, ["2"])));
-                        const shapedResults = await iterate(index.store, new SearchRequest({
-                            query: new BoolQuery({ key: ["nested", "bool"], value: false }),
-                            fetch: 1,
-                        })).all({ shape: { id: true } });
+                        const shapedResults = await index.store
+                            .iterate({
+                            query: new BoolQuery({
+                                key: ["nested", "bool"],
+                                value: false,
+                            }),
+                        }, { shape: { id: true } })
+                            .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal("2");
                         if (shapingSupported) {
-                            expect(shapedResults[0].value.nested).to.be.undefined;
+                            expect(shapedResults[0].value["nested"]).to.be.undefined;
                         }
                         else {
-                            expect(shapedResults[0].value.nested).to.exist;
+                            expect(shapedResults[0].value["nested"]).to.exist;
                         }
-                        const unshapedResults = await iterate(index.store, new SearchRequest({
+                        const unshapedResults = await index.store
+                            .iterate({
                             query: new BoolQuery({ key: ["nested", "bool"], value: false }),
-                            fetch: 1,
-                        })).all();
+                        })
+                            .all();
                         expect(unshapedResults).to.have.length(1);
                         expect(unshapedResults[0].value.id).to.equal("2");
                         expect(unshapedResults[0].value.nested).to.exist;
@@ -2297,17 +2337,19 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         const d2 = new NestedBoolQueryDocument("2", new MultifieldNested(false, 2, ["2"]));
                         await index.store.put(d1);
                         await index.store.put(d2);
-                        const unshapedResults = await iterate(index.store, new SearchRequest({
+                        const unshapedResults = await index.store
+                            .iterate({
                             query: new StringMatch({ key: ["id"], value: "2" }),
-                            fetch: 1,
-                        })).all();
+                        })
+                            .all();
                         expect(unshapedResults).to.have.length(1);
                         expect(unshapedResults[0].value.id).to.equal(d2.id);
                         expect(unshapedResults[0].value.nested).to.deep.equal(d2.nested);
-                        const shapedResults = await iterate(index.store, new SearchRequest({
+                        const shapedResults = await index.store
+                            .iterate({
                             query: new StringMatch({ key: ["id"], value: "2" }),
-                            fetch: 1,
-                        })).all({ shape: { id: true, nested: { bool: true } } });
+                        }, { shape: { id: true, nested: { bool: true } } })
+                            .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal(d2.id);
                         if (shapingSupported) {
@@ -2367,22 +2409,27 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         index = await setup({ schema: NestedBoolQueryDocument });
                         await index.store.put(new NestedBoolQueryDocument("1", new MultifieldNested(true, 1, ["1"])));
                         await index.store.put(new NestedBoolQueryDocument("2", new MultifieldNested(false, 2, ["2"])));
-                        const shapedResults = await iterate(index.store, new SearchRequest({
-                            query: new BoolQuery({ key: ["nested", "bool"], value: false }),
-                            fetch: 1,
-                        })).all({ shape: { id: true } });
+                        const shapedResults = await index.store
+                            .iterate({
+                            query: new BoolQuery({
+                                key: ["nested", "bool"],
+                                value: false,
+                            }),
+                        }, { shape: { id: true } })
+                            .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal("2");
                         if (shapingSupported) {
-                            expect(shapedResults[0].value.nested).to.be.undefined;
+                            expect(shapedResults[0].value["nested"]).to.be.undefined;
                         }
                         else {
-                            expect(shapedResults[0].value.nested).to.exist;
+                            expect(shapedResults[0].value["nested"]).to.exist;
                         }
-                        const unshapedResults = await iterate(index.store, new SearchRequest({
+                        const unshapedResults = await index.store
+                            .iterate({
                             query: new BoolQuery({ key: ["nested", "bool"], value: false }),
-                            fetch: 1,
-                        })).all();
+                        })
+                            .all();
                         expect(unshapedResults).to.have.length(1);
                         expect(unshapedResults[0].value.id).to.equal("2");
                         expect(unshapedResults[0].value.nested).to.exist;
@@ -2393,10 +2440,11 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         const d2 = new NestedBoolQueryDocument("2", new MultifieldNested(false, 2, ["2"]));
                         await index.store.put(d1);
                         await index.store.put(d2);
-                        const shapedResults = await iterate(index.store, new SearchRequest({
+                        const shapedResults = await index.store
+                            .iterate({
                             query: new StringMatch({ key: ["id"], value: "2" }),
-                            fetch: 1,
-                        })).all({ shape: { id: true, nested: { bool: true } } });
+                        }, { shape: { id: true, nested: [{ bool: true }] } })
+                            .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal(d2.id);
                         if (shapingSupported) {
@@ -2407,14 +2455,28 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         else {
                             expect(shapedResults[0].value.nested[0]).to.deep.equal(d2.nested[0]);
                         }
-                        const unshapedResults = await iterate(index.store, new SearchRequest({
+                        const unshapedResults = await index.store
+                            .iterate({
                             query: new StringMatch({ key: ["id"], value: "2" }),
-                            fetch: 1,
-                        })).all();
+                        })
+                            .all();
                         expect(unshapedResults).to.have.length(1);
                         expect(unshapedResults[0].value.id).to.equal(d2.id);
                         expect(unshapedResults[0].value.nested[0]).to.deep.equal(d2.nested[0]);
                     });
+                    it("true resolves fully", async () => {
+                        index = await setup({ schema: NestedBoolQueryDocument });
+                        const d1 = new NestedBoolQueryDocument("1", new MultifieldNested(true, 1, ["1"]));
+                        await index.store.put(d1);
+                        const shapedResults = await index.store
+                            .iterate({
+                            query: [],
+                        }, { shape: { id: true, nested: true } })
+                            .all();
+                        expect(shapedResults).to.have.length(1);
+                        expect(shapedResults[0].value.id).to.equal(d1.id);
+                        expect(shapedResults[0].value.nested[0]).to.deep.equal(d1.nested[0]);
+                    });
                 });
             });
         });
@@ -2439,22 +2501,27 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                 new Sort({ direction: SortDirection.ASC, key: "number" }),
             ]) => {
                 await waitForResolved(async () => {
-                    const req = new SearchRequest({
+                    const req = {
                         query,
                         sort,
-                    });
-                    const iterator = iterate(store, req);
+                    };
+                    const iterator = store.iterate(req);
+                    // No fetches has been made, so we don't know whether we are done yet
+                    expect(iterator.done()).to.be.undefined;
                     if (batches.length === 0) {
-                        // No fetches has been made, so we don't know whether we are done yet
-                        expect(iterator.done()).to.be.false;
+                        await assertIteratorIsDone(iterator);
                     }
                     else {
+                        let first = true;
                         for (const batch of batches) {
-                            expect(iterator.done()).to.be.false;
+                            first
+                                ? expect(iterator.done()).to.be.undefined
+                                : expect(iterator.done()).to.be.false;
+                            first = false;
                             const next = await iterator.next(batch.length);
-                            expect(next.results.map((x) => Number(x.value.number))).to.deep.equal(batch.map((x) => Number(x)));
+                            expect(next.map((x) => Number(x.value.number))).to.deep.equal(batch.map((x) => Number(x)));
                         }
-                        expect(iterator.done()).to.be.true;
+                        await assertIteratorIsDone(iterator);
                     }
                 });
             };
@@ -2481,50 +2548,38 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                 await put(1);
                 await put(2);
                 {
-                    const iterator = await iterate(store, new SearchRequest({
+                    const iterator = store.iterate({
                         query: [],
                         sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
-                    }));
-                    expect(iterator.done()).to.be.false;
+                    });
+                    expect(iterator.done()).to.be.undefined;
                     const next = await iterator.next(3);
-                    expect(next.results.map((x) => x.value.name)).to.deep.equal([
-                        "0",
-                        "1",
-                        "2",
-                    ]);
-                    expect(iterator.done()).to.be.true;
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["0", "1", "2"]);
+                    await assertIteratorIsDone(iterator);
                 }
                 {
-                    const iterator = await iterate(store, new SearchRequest({
+                    const iterator = store.iterate({
                         query: [],
                         sort: [new Sort({ direction: SortDirection.DESC, key: "name" })],
-                    }));
-                    expect(iterator.done()).to.be.false;
+                    });
+                    expect(iterator.done()).to.be.undefined;
                     const next = await iterator.next(3);
-                    expect(next.results.map((x) => x.value.name)).to.deep.equal([
-                        "2",
-                        "1",
-                        "0",
-                    ]);
-                    expect(iterator.done()).to.be.true;
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["2", "1", "0"]);
+                    await assertIteratorIsDone(iterator);
                 }
             });
             it("strings", async () => {
                 await put(0);
                 await put(1);
                 await put(2);
-                const iterator = await iterate(store, new SearchRequest({
+                const iterator = await store.iterate({
                     query: [],
                     sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
-                }));
-                expect(iterator.done()).to.be.false;
+                });
+                expect(iterator.done()).to.be.undefined;
                 const next = await iterator.next(3);
-                expect(next.results.map((x) => x.value.name)).to.deep.equal([
-                    "0",
-                    "1",
-                    "2",
-                ]);
-                expect(iterator.done()).to.be.true;
+                expect(next.map((x) => x.value.name)).to.deep.equal(["0", "1", "2"]);
+                await assertIteratorIsDone(iterator);
             });
             describe("nested", () => {
                 it("variants", async () => {
@@ -2538,17 +2593,18 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     });
                     await store.put(doc1);
                     await store.put(doc2);
-                    const iterator = iterate(store, new SearchRequest({
+                    const iterator = store.iterate({
                         sort: [
                             new Sort({
                                 direction: SortDirection.DESC,
                                 key: ["nested", "number"],
                             }),
                         ],
-                    }));
-                    expect(iterator.done()).to.be.false;
+                    });
+                    expect(iterator.done()).to.be.undefined;
                     const next = await iterator.next(2);
-                    expect(next.results.map((x) => x.value.id)).to.deep.equal(["2", "1"]);
+                    expect(next.map((x) => x.value.id)).to.deep.equal(["2", "1"]);
+                    await assertIteratorIsDone(iterator);
                 });
                 describe("nested-nested-invariant", () => {
                     class V0 {
@@ -2595,20 +2651,18 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         await store.put(doc2);
                     });
                     it("nested-variants", async () => {
-                        const iterator = iterate(store, new SearchRequest({
+                        const iterator = store.iterate({
                             sort: [
                                 new Sort({
                                     direction: SortDirection.DESC,
                                     key: ["nested", "v0", "number"],
                                 }),
                             ],
-                        }));
-                        expect(iterator.done()).to.be.false;
+                        });
+                        expect(iterator.done()).to.be.undefined;
                         const next = await iterator.next(2);
-                        expect(next.results.map((x) => x.value.id)).to.deep.equal([
-                            "2",
-                            "1",
-                        ]);
+                        expect(next.map((x) => x.value.id)).to.deep.equal(["2", "1"]);
+                        await assertIteratorIsDone(iterator);
                     });
                 });
                 describe("variant-nested-invariant", () => {
@@ -2660,79 +2714,76 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         await store.put(doc2);
                     });
                     it("nested-variants", async () => {
-                        const iterator = iterate(store, new SearchRequest({
+                        const iterator = store.iterate({
                             sort: [
                                 new Sort({
                                     direction: SortDirection.DESC,
                                     key: ["nested", "v0", "number"],
                                 }),
                             ],
-                        }));
-                        expect(iterator.done()).to.be.false;
+                        });
+                        expect(iterator.done()).to.be.undefined;
                         const next = await iterator.next(2);
-                        expect(next.results.map((x) => x.value.id)).to.deep.equal([
-                            "2",
-                            "1",
-                        ]);
+                        expect(next.map((x) => x.value.id)).to.deep.equal(["2", "1"]);
                     });
                 });
                 /*  TODO (requires sort join interleaving)
                 
                 describe("nested-nested-variant", () => {
-
+        
                     abstract class Base { }
-
+        
                     @variant(0)
                     class V0 extends Base {
-
+        
                         @field({ type: 'u64' })
                         number: bigint;
-
+        
                         constructor(number: bigint) {
                             super()
                             this.number = number;
                         }
                     }
-
+        
                     @variant(1)
                     class V1 extends Base {
-
+        
                         @field({ type: 'u64' })
                         number: bigint;
-
+        
                         constructor(number: bigint) {
                             super()
                             this.number = number;
                         }
                     }
-
+        
                     class NestedValue {
                         @field({ type: Base })
                         v0: Base;
-
+        
                         constructor(v0?: Base) {
                             this.v0 = v0;
                         }
                     }
-
+        
                     class Document {
                         @id({ type: 'string' })
                         id: string;
-
+        
                         @field({ type: NestedValue })
                         nested: NestedValue;
-
+        
                         constructor(id: string, nested: NestedValue) {
                             this.id = id;
                             this.nested = nested;
                         }
                     }
-
+        
                     const doc1 = new Document("1", new NestedValue(new V0(1n)));
                     const doc2 = new Document("2", new NestedValue(new V0(2n)));
                     const doc3 = new Document("3", new NestedValue(new V1(3n)));
                     const doc4 = new Document("4", new NestedValue(new V1(4n)));
-
+        
                     beforeEach(async () => {
                         await setup({ schema: Document });
                         await store.put(doc1);
@@ -2740,15 +2791,15 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         await store.put(doc3);
                         await store.put(doc4);
                     });
-
+        
                     it("nested-variants", async () => {
-                        const iterator = iterate(store, new SearchRequest({ sort: [new Sort({ direction: SortDirection.DESC, key: ["nested", "v0", "number"] })] }));
+                        const iterator = iterate(store, ({ sort: [new Sort({ direction: SortDirection.DESC, key: ["nested", "v0", "number"] })] }));
                         expect(iterator.done()).to.be.false;
                         const next = await iterator.next(4);
                         expect(next.results.map((x) => x.value.id)).to.deep.equal(["4", "3", "2", "1"]);
-
+        
                     })
-
+        
                 })*/
                 /* TODO
                 it("array sort", async () => {
@@ -2774,7 +2825,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     await store.put(doc2);
                     await store.put(doc3);
         
-                    const iterator = iterate(store, new SearchRequest({ query: [new IntegerCompare({ key: 'number', compare: 'gte', value: 102n }), new Nested({ path: 'nestedVec', id: 'path-to-nested', query: [new IntegerCompare({ key: 'number', compare: 'gte', value: 200 })] })], sort: [new Sort({ direction: SortDirection.DESC, key: ["path-to-nested", "number"] })] }));
+                    const iterator = iterate(store, ({ query: [new IntegerCompare({ key: 'number', compare: 'gte', value: 102n }), new Nested({ path: 'nestedVec', id: 'path-to-nested', query: [new IntegerCompare({ key: 'number', compare: 'gte', value: 200 })] })], sort: [new Sort({ direction: SortDirection.DESC, key: ["path-to-nested", "number"] })] }));
                     expect(iterator.done()).to.be.false;
                     const next = await iterator.next(2);
                     expect(next.results.map((x) => x.value.id)).to.deep.equal(["2", "1"]);
@@ -2786,40 +2837,43 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     await put(0);
                     await put(1);
                     await put(2);
-                    const request = new SearchRequest({
+                    const request = {
                         query: [],
-                    });
-                    const iterator = iterate(store, request);
-                    expect(iterator.done()).to.be.false;
+                    };
+                    const iterator = store.iterate(request);
+                    expect(iterator.done()).to.be.undefined;
                     await iterator.next(2); // fetch some, but not all
-                    expect(store.getPending(request.idString)).equal(1);
+                    expect(iterator.done()).to.be.false;
+                    expect(await iterator.pending()).equal(1);
                     await iterator.close();
-                    await waitForResolved(() => expect(store.getPending(request.idString)).equal(undefined), { timeout: 3000, delayInterval: 50 });
+                    expect(await iterator.pending()).equal(0);
+                    expect(iterator.done()).to.be.true;
                 });
                 it("end of iterator", async () => {
                     await put(0);
                     await put(1);
                     await put(2);
-                    const request = new SearchRequest({
+                    const request = {
                         query: [],
-                    });
-                    const iterator = await iterate(store, request);
-                    expect(iterator.done()).to.be.false;
+                    };
+                    const iterator = store.iterate(request);
+                    expect(iterator.done()).to.be.undefined;
                     await iterator.next(3); // fetch all
-                    await waitForResolved(() => expect(store.getPending(request.idString)).equal(undefined), { timeout: 3000, delayInterval: 50 });
+                    expect(await iterator.pending()).equal(0);
+                    expect(iterator.done()).to.be.true;
                 });
                 it("end of iterator, multiple nexts", async () => {
                     await put(0);
                     await put(1);
                     await put(2);
-                    const request = new SearchRequest({
+                    const request = {
                         query: [],
-                    });
-                    const iterator = await iterate(store, request);
+                    };
+                    const iterator = store.iterate(request);
                     await iterator.next(2);
                     await iterator.next(1);
-                    expect(iterator.done()).to.be.true;
-                    await waitForResolved(() => expect(store.getPending(request.idString)).equal(undefined), { timeout: 3000, delayInterval: 50 });
+                    assertIteratorIsDone(iterator);
+                    expect(await iterator.pending()).equal(0);
                 });
             });
             // TODO test iterator.close() to stop pending promises
@@ -2829,14 +2883,14 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
         describe("sum", () => {
             it("it returns sum", async () => {
                 await setupDefault();
-                const sum = await store.sum(new SumRequest({ key: "number" }));
+                const sum = await store.sum({ key: "number" });
                 typeof sum === "bigint"
                     ? expect(sum).to.equal(6n)
                     : expect(sum).to.equal(6);
             });
             it("it returns sum with query", async () => {
                 await setupDefault();
-                const sum = await store.sum(new SumRequest({
+                const sum = await store.sum({
                     key: "number",
                     query: [
                         new StringMatch({
@@ -2846,7 +2900,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             caseInsensitive: true,
                         }),
                     ],
-                }));
+                });
                 typeof sum === "bigint"
                     ? expect(sum).to.equal(2n)
                     : expect(sum).to.equal(2);
@@ -2867,9 +2921,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                 await store.put(doc1);
                 await store.put(doc2);
                 await store.put(doc3);
-                const sum = await store.sum(new SumRequest({
+                const sum = await store.sum({
                     key: ["nested", "number"],
-                }));
+                });
                 typeof sum === "bigint"
                     ? expect(sum).to.equal(3n)
                     : expect(sum).to.equal(3);
@@ -2878,12 +2932,12 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
         describe("count", () => {
             it("it returns count", async () => {
                 await setupDefault();
-                const sum = await store.count(new CountRequest());
+                const sum = await store.count();
                 expect(sum).to.equal(4);
             });
             it("it returns count with query", async () => {
                 await setupDefault();
-                const sum = await store.count(new CountRequest({
+                const sum = await store.count({
                     query: [
                         new StringMatch({
                             key: "tags",
@@ -2892,14 +2946,14 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             caseInsensitive: true,
                         }),
                     ],
-                }));
+                });
                 expect(sum).to.equal(1);
             });
         });
         describe("delete", () => {
             it("delete with query", async () => {
                 await setupDefault();
-                await store.del(new DeleteRequest({
+                await store.del({
                     query: [
                         new StringMatch({
                             key: "tags",
@@ -2908,7 +2962,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             caseInsensitive: true,
                         }),
                     ],
-                }));
+                });
                 expect(await store.getSize()).to.equal(3);
             });
         });
@@ -2938,7 +2992,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                 await setupDefault();
                 for (let i = 0; i < 100; i++) {
                     promises.push((async () => {
-                        results.push(await store.count(new CountRequest()));
+                        results.push(await store.count());
                     })());
                 }
                 await Promise.all(promises);
@@ -3079,9 +3133,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     schema: AnotherDocument,
                 });
                 await aIndex.put(new Document({ id: "a", name: "hello", number: 1n, tags: [] }));
-                expect(await aIndex.count(new CountRequest({ query: { id: "a" } }))).to.eq(1);
+                expect(await aIndex.count({ query: { id: "a" } })).to.eq(1);
                 await bIndex.put(new AnotherDocument("b"));
-                expect(await bIndex.count(new CountRequest({ query: { id: "b" } }))).to.eq(1);
+                expect(await bIndex.count({ query: { id: "b" } })).to.eq(1);
             });
         });
     });
@@ -3132,7 +3186,7 @@ describe("multi-dimensional", () => {
                                     promises.push(
                                         search(
                                             store,
-                                            new SearchRequest({
+                                            ({
                                                 query: [
                                                     new IntegerCompare({
                                                         key: "number",
@@ -3147,7 +3201,7 @@ describe("multi-dimensional", () => {
                                     promises.push(
                                         search(
                                             store,
-                                            new SearchRequest({
+                                            ({
                                                 query: [
                                                     new IntegerCompare({
                                                         key: "number",