@snowtop/ent 0.1.0-alpha1 → 0.1.0-alpha100

package/core/query/shared_test.js

@@ -1,190 +1,305 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonTests = void 0;
-const db_mock_1 = require("../../testutils/db_mock");
 const ent_1 = require("../ent");
 const viewer_1 = require("../viewer");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
-const test_db_1 = require("../../testutils/db/test_db");
+const temp_db_1 = require("../../testutils/db/temp_db");
 const test_context_1 = require("../../testutils/context/test_context");
 const logger_1 = require("../logger");
-class TestQueryFilter {
-    constructor(filter, newQuery, ents, defaultViewer) {
-        this.filter = filter;
-        this.newQuery = newQuery;
-        this.ents = ents;
-        this.defaultViewer = defaultViewer;
-        this.allContacts = [];
-        this.filteredContacts = [];
+const test_edge_global_schema_1 = require("../../testutils/test_edge_global_schema");
+const builder_1 = require("../../testutils/builder");
+const action_1 = require("../../action");
+const clause_1 = require("../clause");
+function getWhereClause(query) {
+    const idx = query.query.indexOf("WHERE");
+    if (idx !== -1) {
+        return query.query.substr(idx + 6);
     }
-    async beforeEach() {
-        //    console.log("sss");
-        [this.user, this.allContacts] = await (0, test_helpers_1.createAllContacts)();
-        //    console.log(this.user, this.contacts);
-        //    this.allContacts = this.allContacts.reverse();
-        this.filteredContacts = this.ents(this.allContacts);
-        db_mock_1.QueryRecorder.clearQueries();
-    }
-    getQuery(viewer) {
-        return this.filter(this.newQuery(viewer || this.defaultViewer, this.user), this.user, this.allContacts);
-    }
-    async testIDs() {
-        const ids = await this.getQuery().queryIDs();
-        this.verifyIDs(ids);
-    }
-    verifyIDs(ids) {
-        expect(ids).toEqual(this.filteredContacts.map((contact) => contact.id));
-    }
-    // rawCount isn't affected by filters...
-    async testRawCount() {
-        const count = await this.getQuery().queryRawCount();
-        this.verifyRawCount(count);
-    }
-    verifyRawCount(count) {
-        expect(count).toBe(test_helpers_1.inputs.length);
-    }
-    async testCount() {
-        const count = await this.getQuery().queryCount();
-        this.verifyCount(count);
-    }
-    verifyCount(count) {
-        expect(count).toBe(this.filteredContacts.length);
-    }
-    async testEdges() {
-        const edges = await this.getQuery().queryEdges();
-        this.verifyEdges(edges);
-    }
-    verifyEdges(edges) {
-        const q = this.getQuery();
+    return null;
+}
+const commonTests = (opts) => {
+    (0, logger_1.setLogLevels)(["query", "error"]);
+    const ml = opts.ml;
+    ml.mock();
+    function isCustomQuery(q) {
+        if (q.customQuery !== undefined) {
+            return q.customQuery;
+        }
         // TODO sad not generic enough
-        if (q instanceof index_1.UserToContactsFkeyQuery) {
-            (0, test_helpers_1.verifyUserToContactRawData)(this.user, edges, this.filteredContacts);
+        return (q instanceof index_1.UserToContactsFkeyQuery ||
+            q instanceof index_1.UserToContactsFkeyQueryDeprecated ||
+            q instanceof index_1.UserToContactsFkeyQueryAsc);
+    }
+    class TestQueryFilter {
+        constructor(filter, newQuery, ents, defaultViewer) {
+            this.filter = filter;
+            this.newQuery = newQuery;
+            this.ents = ents;
+            this.defaultViewer = defaultViewer;
+            this.allContacts = [];
+            this.filteredContacts = [];
+            // @ts-ignore
+            const q = this.newQuery(this.defaultViewer);
+            this.customQuery = isCustomQuery(q);
         }
-        else {
-            (0, test_helpers_1.verifyUserToContactEdges)(this.user, edges, this.filteredContacts);
+        async createData() {
+            [this.user, this.allContacts] = await (0, test_helpers_1.createAllContacts)();
+            //    this.allContacts = this.allContacts.reverse();
+            this.filteredContacts = this.ents(this.allContacts);
+            ml.clear();
         }
-    }
-    async testEnts() {
-        const entsMap = await this.getQuery(new viewer_1.IDViewer(this.user.id)).queryEnts();
-        this.verifyEnts(entsMap);
-    }
-    verifyEnts(ents) {
-        (0, test_helpers_1.verifyUserToContacts)(this.user, ents, this.filteredContacts);
-    }
-    async testAll() {
-        const query = this.getQuery(new viewer_1.IDViewer(this.user.id));
-        const [edges, count, ids, rawCount, ents] = await Promise.all([
-            query.queryEdges(),
-            query.queryCount(),
-            query.queryIDs(),
-            query.queryRawCount(),
-            query.queryEnts(),
-        ]);
-        this.verifyCount(count);
-        this.verifyEdges(edges);
-        this.verifyIDs(ids);
-        this.verifyRawCount(rawCount);
-        this.verifyEnts(ents);
-    }
-}
-const preparedVar = /(\$(\d))/g;
-const commonTests = (opts) => {
-    function verifyQuery({ length = 1, numQueries = 1, limit = ent_1.DefaultLimit, disablePaginationBump = false, }) {
-        if (opts.livePostgresDB || opts.sqlite) {
-            return;
+        getQuery(viewer) {
+            return this.filter(this.newQuery(viewer || this.defaultViewer, this.user), this.user, this.allContacts);
+        }
+        async testIDs() {
+            const ids = await this.getQuery().queryIDs();
+            this.verifyIDs(ids);
+        }
+        verifyIDs(ids) {
+            expect(ids).toEqual(this.filteredContacts.map((contact) => contact.id));
         }
-        const queries = db_mock_1.QueryRecorder.getCurrentQueries();
-        expect(queries.length).toBe(length);
+        // rawCount isn't affected by filters...
+        async testRawCount(expectedCount) {
+            const count = await this.getQuery().queryRawCount();
+            this.verifyRawCount(count, expectedCount);
+        }
+        verifyRawCount(count, expectedCount) {
+            expect(count).toBe(expectedCount ?? test_helpers_1.inputs.length);
+        }
+        async testCount(expectedCount) {
+            const count = await this.getQuery().queryCount();
+            this.verifyCount(count, expectedCount);
+        }
+        verifyCount(count, expectedCount) {
+            expect(count).toBe(expectedCount ?? this.filteredContacts.length);
+        }
+        async testEdges() {
+            const edges = await this.getQuery().queryEdges();
+            this.verifyEdges(edges);
+        }
+        verifyEdges(edges) {
+            // TODO sad not generic enough
+            if (this.customQuery) {
+                (0, test_helpers_1.verifyUserToContactRawData)(this.user, edges, this.filteredContacts);
+            }
+            else {
+                (0, test_helpers_1.verifyUserToContactEdges)(this.user, edges, this.filteredContacts);
+            }
+        }
+        async testEnts(v) {
+            const ents = await this.getQuery(v || new viewer_1.IDViewer(this.user.id)).queryEnts();
+            this.verifyEnts(ents);
+            return ents;
+        }
+        async testEntsCache() {
+            if (!this.customQuery) {
+                return;
+            }
+            (0, logger_1.setLogLevels)(["query", "cache"]);
+            const v = new test_context_1.TestContext(new viewer_1.IDViewer(this.user.id)).getViewer();
+            const ents = await this.testEnts(v);
+            expect(ml.logs.length).toBe(1);
+            expect(ml.logs[0].query).toMatch(/SELECT (.+) FROM /);
+            await Promise.all(ents.map((ent) => index_1.FakeContact.loadX(v, ent.id)));
+            expect(ml.logs.length).toBe(this.filteredContacts.length + 1);
+            for (const log of ml.logs.slice(1)) {
+                expect(log["ent-cache-hit"]).toBeDefined();
+            }
+            // "restore" back to previous
+            (0, logger_1.setLogLevels)("query");
+        }
+        async testDataCache() {
+            if (!this.customQuery) {
+                return;
+            }
+            (0, logger_1.setLogLevels)(["query", "cache"]);
+            const v = new test_context_1.TestContext(new viewer_1.IDViewer(this.user.id)).getViewer();
+            const ents = await this.testEnts(v);
+            expect(ml.logs.length).toBe(1);
+            expect(ml.logs[0].query).toMatch(/SELECT (.+) FROM /);
+            await Promise.all(ents.map((ent) => index_1.FakeContact.loadRawData(ent.id, v.context)));
+            expect(ml.logs.length).toBe(this.filteredContacts.length + 1);
+            for (const log of ml.logs.slice(1)) {
+                expect(log["dataloader-cache-hit"]).toBeDefined();
+            }
+            // "restore" back to previous
+            (0, logger_1.setLogLevels)("query");
+        }
+        verifyEnts(ents) {
+            (0, test_helpers_1.verifyUserToContacts)(this.user, ents, this.filteredContacts);
+        }
+        async testAll(expectedCount) {
+            const query = this.getQuery(new viewer_1.IDViewer(this.user.id));
+            const [edges, count, ids, rawCount, ents] = await Promise.all([
+                query.queryEdges(),
+                query.queryCount(),
+                query.queryIDs(),
+                query.queryRawCount(),
+                query.queryEnts(),
+            ]);
+            this.verifyCount(count, expectedCount);
+            this.verifyEdges(edges);
+            this.verifyIDs(ids);
+            this.verifyRawCount(rawCount, expectedCount);
+            this.verifyEnts(ents);
+        }
+    }
+    function verifyQuery(filter, { length = 1, numQueries = 1, limit = ent_1.DefaultLimit, disablePaginationBump = false, orderby = opts.orderby, }) {
+        const uniqCol = isCustomQuery(filter) ? "id" : "id2";
+        expect(ml.logs.length).toBe(length);
         for (let i = 0; i < numQueries; i++) {
-            const query = queries[i];
+            const whereClause = getWhereClause(ml.logs[i]);
             let expLimit = disablePaginationBump ? limit : limit + 1;
-            expect(query.qs?.whereClause, `${i}`).toBe(
+            expect(whereClause, `${i}`).toBe(
             // default limit
-            `${opts.where} ORDER BY ${opts.sortCol} DESC LIMIT ${expLimit}`);
+            `${opts.clause.clause(1)} ORDER BY ${opts.sortCol} ${orderby}, ${uniqCol} ${orderby} LIMIT ${expLimit}`);
         }
     }
     function verifyCountQuery({ length = 1, numQueries = 1 }) {
-        if (opts.livePostgresDB || opts.sqlite) {
-            return;
-        }
-        const queries = db_mock_1.QueryRecorder.getCurrentQueries();
-        expect(queries.length).toBe(length);
+        expect(ml.logs.length).toBe(length);
         for (let i = 0; i < numQueries; i++) {
-            const query = queries[i];
-            expect(query.qs?.whereClause).toBe(opts.where);
-            expect(query.qs?.columns).toHaveLength(1);
-            expect(query.qs?.columns).toStrictEqual(["count(1) as count"]);
+            const whereClause = getWhereClause(ml.logs[i]);
+            expect(whereClause).toBe(opts.clause.clause(1));
         }
     }
-    function verifyFirstAfterCursorQuery(length = 1) {
-        if (opts.livePostgresDB || opts.sqlite) {
-            return;
+    function verifyFirstAfterCursorQuery(filter, length = 1, limit = 3) {
+        // cache showing up in a few because of cross runs...
+        expect(ml.logs.length).toBeGreaterThanOrEqual(length);
+        const uniqCol = isCustomQuery(filter) ? "id" : "id2";
+        let parts = opts.clause.clause(1).split(" AND ");
+        const cmp = (0, clause_1.PaginationMultipleColsSubQuery)(opts.sortCol, opts.orderby === "DESC" ? "<" : ">", opts.tableName, uniqCol, "").clause(opts.clause.values().length + 1);
+        if (parts[parts.length - 1] === "deleted_at IS NULL") {
+            parts = parts
+                .slice(0, parts.length - 1)
+                .concat([cmp, "deleted_at IS NULL"]);
+        }
+        else {
+            parts.push(cmp);
         }
-        const queries = db_mock_1.QueryRecorder.getCurrentQueries();
-        expect(queries.length).toBe(length);
-        const query = queries[0];
-        const result = [...opts.where.matchAll(preparedVar)];
-        expect(query.qs?.whereClause).toBe(`${opts.where} AND ${opts.sortCol} < $${result.length + 1} ORDER BY ${opts.sortCol} DESC LIMIT 4`);
+        expect(getWhereClause(ml.logs[0])).toBe(`${parts.join(" AND ")} ORDER BY ${opts.sortCol} ${opts.orderby}, ${uniqCol} ${opts.orderby} LIMIT ${limit + 1}`);
     }
-    function verifyLastBeforeCursorQuery(length = 1) {
-        if (opts.livePostgresDB || opts.sqlite) {
-            return;
+    function verifyLastBeforeCursorQuery(filter, length = 1, limit = 3) {
+        // cache showing up in a few because of cross runs...
+        expect(ml.logs.length).toBeGreaterThanOrEqual(length);
+        const uniqCol = isCustomQuery(filter) ? "id" : "id2";
+        let op = "";
+        let orderby = "";
+        if (opts.orderby === "DESC") {
+            op = ">";
+            orderby = "ASC";
+        }
+        else {
+            op = "<";
+            orderby = "DESC";
+        }
+        let parts = opts.clause.clause(1).split(" AND ");
+        const cmp = (0, clause_1.PaginationMultipleColsSubQuery)(opts.sortCol, op, opts.tableName, uniqCol, "").clause(opts.clause.values().length + 1);
+        if (parts[parts.length - 1] === "deleted_at IS NULL") {
+            parts = parts
+                .slice(0, parts.length - 1)
+                .concat([cmp, "deleted_at IS NULL"]);
+        }
+        else {
+            parts.push(cmp);
         }
-        const queries = db_mock_1.QueryRecorder.getCurrentQueries();
-        expect(queries.length).toBe(length);
-        const query = queries[0];
-        const result = [...opts.where.matchAll(preparedVar)];
-        expect(query.qs?.whereClause).toBe(
+        expect(getWhereClause(ml.logs[0])).toBe(
         // extra fetched for pagination
-        `${opts.where} AND ${opts.sortCol} > $${result.length + 1} ORDER BY ${opts.sortCol} ASC LIMIT 4`);
+        `${parts.join(" AND ")} ORDER BY ${opts.sortCol} ${orderby}, ${uniqCol} ${orderby} LIMIT ${limit + 1}`);
     }
     function getViewer() {
-        // live db, let's do context because we're testing complicated paths
-        // may be worth breaking this out later
-        // opts.liveDB no context too...
-        // maybe this one we just always hit the db
-        // we don't get value out of testing parse_sql no context....
-        if (opts.livePostgresDB || opts.sqlite) {
-            return new test_context_1.TestContext().getViewer();
-        }
-        // no context when not live db
         return new viewer_1.LoggedOutViewer();
     }
     function getCursorFrom(contacts, idx) {
-        // we depend on the fact that the same time is used for the edge and created_at
-        // based on getContactBuilder
-        // so regardless of if we're doing assoc or custom queries, we can get the time
-        // from the created_at field
         return (0, ent_1.getCursor)({
             row: contacts[idx],
-            col: "createdAt",
-            conv: (t) => {
-                //sqlite
-                if (typeof t === "string") {
-                    return Date.parse(t);
-                }
-                return t.getTime();
-            },
-            // we want the right column to be encoded in the cursor as opposed e.g. time for
-            // assoc queries, created_at for index/custom queries
-            cursorKey: opts.sortCol,
+            col: "id",
         });
     }
+    function getVerifyAfterEachCursor(edges, pageLength, user) {
+        let query;
+        async function verify(i, hasEdge, hasNextPage, cursor) {
+            ml.clear();
+            query = opts.newQuery(getViewer(), user);
+            const newEdges = await query.first(pageLength, cursor).queryEdges();
+            const pagination = query.paginationInfo().get(user.id);
+            if (hasEdge) {
+                expect(newEdges[0], `${i}`).toStrictEqual(edges[i]);
+                expect(newEdges.length, `${i}`).toBe(edges.length - i >= pageLength ? pageLength : edges.length - i);
+            }
+            else {
+                expect(newEdges.length, `${i}`).toBe(0);
+            }
+            if (hasNextPage) {
+                expect(pagination?.hasNextPage, `${i}`).toBe(true);
+                expect(pagination?.hasPreviousPage, `${i}`).toBe(false);
+            }
+            else {
+                expect(pagination?.hasNextPage, `${i}`).toBe(undefined);
+                expect(pagination?.hasNextPage, `${i}`).toBe(undefined);
+            }
+            if (cursor) {
+                verifyFirstAfterCursorQuery(query, 1, pageLength);
+            }
+            else {
+                verifyQuery(query, { orderby: opts.orderby, limit: pageLength });
+            }
+        }
+        function getCursor(edge) {
+            return query.getCursor(edge);
+        }
+        return { verify, getCursor };
+    }
+    function getVerifyBeforeEachCursor(edges, pageLength, user) {
+        let query;
+        async function verify(i, hasEdge, hasPreviousPage, cursor) {
+            ml.clear();
+            query = opts.newQuery(getViewer(), user);
+            const newEdges = await query.last(pageLength, cursor).queryEdges();
+            const pagination = query.paginationInfo().get(user.id);
+            if (hasEdge) {
+                expect(newEdges.length, `${i}`).toBe(i >= pageLength ? pageLength : i + 1);
+                expect(newEdges[0], `${i}`).toStrictEqual(edges[i]);
+            }
+            else {
+                expect(newEdges.length, `${i}`).toBe(0);
+            }
+            if (hasPreviousPage) {
+                expect(pagination?.hasPreviousPage, `${i}`).toBe(true);
+                expect(pagination?.hasNextPage, `${i}`).toBe(false);
+            }
+            else {
+                expect(pagination?.hasPreviousPage, `${i}`).toBe(undefined);
+                expect(pagination?.hasNextPage, `${i}`).toBe(undefined);
+            }
+            if (cursor) {
+                verifyLastBeforeCursorQuery(query, 1, pageLength);
+            }
+            else {
+                verifyQuery(query, {
+                    orderby: opts.orderby === "DESC" ? "ASC" : "DESC",
+                    limit: pageLength,
+                });
+            }
+        }
+        function getCursor(edge) {
+            return query.getCursor(edge);
+        }
+        return { verify, getCursor };
+    }
+    if (opts.globalSchema) {
+        (0, ent_1.setGlobalSchema)(test_edge_global_schema_1.testEdgeGlobalSchema);
+    }
     let tdb;
     if (opts.sqlite) {
-        // tableName just to make it unique
-        (0, test_db_1.setupSqlite)(`sqlite:///shared_test+${opts.tableName}.db`, test_helpers_1.tempDBTables);
+        (0, temp_db_1.setupSqlite)(`sqlite:///shared_test+${opts.uniqKey}.db`, () => (0, test_helpers_1.tempDBTables)(opts.globalSchema), {
+            disableDeleteAfterEachTest: true,
+        });
     }
     beforeAll(async () => {
-        // want error on by default in tests?
-        (0, logger_1.setLogLevels)(["error", "warn", "info"]);
-        if (opts.livePostgresDB) {
-            tdb = await (0, test_helpers_1.setupTempDB)();
-        }
-    });
-    beforeEach(async () => {
         if (opts.livePostgresDB) {
+            tdb = await (0, test_helpers_1.setupTempDB)(opts.globalSchema);
             return;
         }
         await (0, test_helpers_1.createEdges)();
@@ -196,19 +311,22 @@ const commonTests = (opts) => {
     });
     describe("simple queries", () => {
         const filter = new TestQueryFilter((q) => {
-            // no filterzs
+            // no filters
             return q;
         }, opts.newQuery, (contacts) => {
             // nothing to do here
             // reverse because edges are most recent first
-            return contacts.reverse();
+            if (opts.orderby === "DESC") {
+                return contacts.reverse();
+            }
+            return contacts;
         }, getViewer());
         beforeEach(async () => {
-            await filter.beforeEach();
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
-            verifyQuery({});
+            verifyQuery(filter, {});
         });
         test("rawCount", async () => {
             await filter.testRawCount();
@@ -216,19 +334,80 @@ const commonTests = (opts) => {
         });
         test("count", async () => {
             await filter.testCount();
-            verifyQuery({});
+            verifyQuery(filter, {});
         });
         test("edges", async () => {
             await filter.testEdges();
-            verifyQuery({});
+            verifyQuery(filter, {});
         });
         test("ents", async () => {
             await filter.testEnts();
-            verifyQuery({ length: opts.entsLength });
+            verifyQuery(filter, { length: opts.entsLength });
         });
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
+    });
+    describe("after delete", () => {
+        const filter = new TestQueryFilter((q) => {
+            // no filters
+            return q;
+        }, opts.newQuery, (contacts) => {
+            // nothing expected since deleted
+            return [];
+        }, getViewer());
+        beforeEach(async () => {
+            await filter.createData();
+            const action = new builder_1.SimpleAction(filter.user.viewer, index_1.FakeUserSchema, new Map(), action_1.WriteOperation.Edit, filter.user);
+            await Promise.all(filter.allContacts.map(async (contact) => {
+                action.builder.orchestrator.removeOutboundEdge(contact.id, index_1.EdgeType.UserToContacts);
+                const action2 = new builder_1.SimpleAction(filter.user.viewer, index_1.FakeContactSchema, new Map(), action_1.WriteOperation.Delete, contact);
+                await action2.save();
+            }));
+            await action.save();
+            ml.clear();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+            verifyQuery(filter, {});
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount(0);
+            verifyCountQuery({});
+        });
+        test("count", async () => {
+            await filter.testCount(0);
+            verifyQuery(filter, {});
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+            verifyQuery(filter, {});
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+            // no ents so no subsequent query. just the edge query
+            verifyQuery(filter, { length: 1 });
+        });
+        test("all", async () => {
+            await filter.testAll(0);
+        });
+        test("raw_data", async () => {
+            if (opts.rawDataVerify) {
+                await opts.rawDataVerify(filter.user);
+            }
+        });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     describe("first. no cursor", () => {
         const N = 2;
@@ -236,14 +415,17 @@ const commonTests = (opts) => {
             // no filters
             return q.first(N);
         }, opts.newQuery, (contacts) => {
-            return contacts.reverse().slice(0, N);
+            if (opts.orderby === "DESC") {
+                return contacts.reverse().slice(0, N);
+            }
+            return contacts.slice(0, N);
         }, getViewer());
         beforeEach(async () => {
-            await filter.beforeEach();
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
-            verifyQuery({ limit: 2 });
+            verifyQuery(filter, { limit: 2 });
         });
         test("rawCount", async () => {
             await filter.testRawCount();
@@ -251,19 +433,25 @@ const commonTests = (opts) => {
         });
         test("count", async () => {
             await filter.testCount();
-            verifyQuery({ limit: 2 });
+            verifyQuery(filter, { limit: 2 });
         });
         test("edges", async () => {
             await filter.testEdges();
-            verifyQuery({ limit: 2 });
+            verifyQuery(filter, { limit: 2 });
         });
         test("ents", async () => {
             await filter.testEnts();
-            verifyQuery({ limit: 2, length: opts.entsLength });
+            verifyQuery(filter, { limit: 2, length: opts.entsLength });
         });
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     describe("last", () => {
         const N = 2;
@@ -271,15 +459,23 @@ const commonTests = (opts) => {
             // no filters
             return q.last(N);
         }, opts.newQuery, (contacts) => {
-            // take the first N and then reverse it to get the last N in the right order
-            return contacts.slice(0, N).reverse();
+            if (opts.orderby === "DESC") {
+                return contacts.slice(0, N);
+            }
+            else {
+                return contacts.reverse().slice(0, N);
+            }
         }, getViewer());
+        const orderby = opts.orderby === "ASC" ? "DESC" : "ASC";
         beforeEach(async () => {
-            await filter.beforeEach();
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
-            verifyQuery({ disablePaginationBump: true });
+            verifyQuery(filter, {
+                orderby,
+                limit: N,
+            });
         });
         test("rawCount", async () => {
             await filter.testRawCount();
@@ -287,19 +483,29 @@ const commonTests = (opts) => {
         });
         test("count", async () => {
             await filter.testCount();
-            verifyQuery({ disablePaginationBump: true });
+            verifyQuery(filter, { orderby, limit: N });
         });
         test("edges", async () => {
             await filter.testEdges();
-            verifyQuery({ disablePaginationBump: true });
+            verifyQuery(filter, { orderby, limit: N });
         });
         test("ents", async () => {
             await filter.testEnts();
-            verifyQuery({ disablePaginationBump: true, length: opts.entsLength });
+            verifyQuery(filter, {
+                orderby,
+                limit: N,
+                length: opts.entsLength,
+            });
         });
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     describe("first after cursor", () => {
         const idx = 2;
@@ -307,15 +513,23 @@ const commonTests = (opts) => {
         const filter = new TestQueryFilter((q, user, contacts) => {
             return q.first(N, getCursorFrom(contacts, idx));
         }, opts.newQuery, (contacts) => {
-            // < check so we shouldn't get that index
-            return contacts.reverse().slice(idx + 1, idx + N);
+            if (opts.orderby === "DESC") {
+                // < check so we shouldn't get that index
+                return contacts.reverse().slice(idx + 1, idx + N);
+            }
+            else {
+                return contacts.slice(idx + 1, idx + N);
+            }
         }, getViewer());
-        beforeEach(async () => {
-            await filter.beforeEach();
+        beforeAll(async () => {
+            await filter.createData();
+        });
+        beforeEach(() => {
+            ml.clear();
         });
         test("ids", async () => {
             await filter.testIDs();
-            verifyFirstAfterCursorQuery();
+            verifyFirstAfterCursorQuery(filter);
         });
         test("rawCount", async () => {
             await filter.testRawCount();
@@ -323,51 +537,36 @@ const commonTests = (opts) => {
         });
         test("count", async () => {
             await filter.testCount();
-            verifyFirstAfterCursorQuery();
+            verifyFirstAfterCursorQuery(filter);
         });
         test("edges", async () => {
             await filter.testEdges();
-            verifyFirstAfterCursorQuery();
+            verifyFirstAfterCursorQuery(filter);
         });
         test("ents", async () => {
             await filter.testEnts();
-            verifyFirstAfterCursorQuery(opts.entsLength);
+            verifyFirstAfterCursorQuery(filter, opts.entsLength);
         });
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     test("first. after each cursor", async () => {
-        let [user, contacts] = await (0, test_helpers_1.createAllContacts)();
-        contacts = contacts.reverse();
+        let [user] = await (0, test_helpers_1.createAllContacts)();
         const edges = await opts.newQuery(getViewer(), user).queryEdges();
-        let query;
-        async function verify(i, hasEdge, hasNextPage, cursor) {
-            query = opts.newQuery(getViewer(), user);
-            const newEdges = await query.first(1, cursor).queryEdges();
-            const pagination = query.paginationInfo().get(user.id);
-            if (hasEdge) {
-                expect(newEdges.length, `${i}`).toBe(1);
-                expect(newEdges[0], `${i}`).toStrictEqual(edges[i]);
-            }
-            else {
-                expect(newEdges.length, `${i}`).toBe(0);
-            }
-            if (hasNextPage) {
-                expect(pagination?.hasNextPage).toBe(true);
-                expect(pagination?.hasPreviousPage).toBe(false);
-            }
-            else {
-                expect(pagination?.hasNextPage).toBe(undefined);
-                expect(pagination?.hasNextPage).toBe(undefined);
-            }
-        }
+        const { verify, getCursor } = getVerifyAfterEachCursor(edges, 1, user);
         await verify(0, true, true, undefined);
-        await verify(1, true, true, query.getCursor(edges[0]));
-        await verify(2, true, true, query.getCursor(edges[1]));
-        await verify(3, true, true, query.getCursor(edges[2]));
-        await verify(4, true, false, query.getCursor(edges[3]));
-        await verify(5, false, false, query.getCursor(edges[4]));
+        await verify(1, true, true, getCursor(edges[0]));
+        await verify(2, true, true, getCursor(edges[1]));
+        await verify(3, true, true, getCursor(edges[2]));
+        await verify(4, true, false, getCursor(edges[3]));
+        await verify(5, false, false, getCursor(edges[4]));
     });
     describe("last. before cursor", () => {
         const idx = 2;
@@ -376,14 +575,22 @@ const commonTests = (opts) => {
             return q.last(N, getCursorFrom(contacts, idx));
         }, opts.newQuery, (contacts) => {
             // > check so we don't want that index
-            return contacts.reverse().slice(0, idx).reverse(); // because of order returned
+            if (opts.orderby === "DESC") {
+                return contacts.reverse().slice(0, idx).reverse(); // because of order returned
+            }
+            return contacts.slice(0, idx).reverse(); // because of order returned
         }, getViewer());
+        beforeAll(async () => {
+            if (opts.livePostgresDB || opts.sqlite) {
+                await filter.createData();
+            }
+        });
         beforeEach(async () => {
-            await filter.beforeEach();
+            ml.clear();
         });
         test("ids", async () => {
             await filter.testIDs();
-            verifyLastBeforeCursorQuery();
+            verifyLastBeforeCursorQuery(filter);
         });
         test("rawCount", async () => {
             await filter.testRawCount();
@@ -391,51 +598,77 @@ const commonTests = (opts) => {
         });
         test("count", async () => {
             await filter.testCount();
-            verifyLastBeforeCursorQuery();
+            verifyLastBeforeCursorQuery(filter);
         });
         test("edges", async () => {
             await filter.testEdges();
-            verifyLastBeforeCursorQuery();
+            verifyLastBeforeCursorQuery(filter);
         });
         test("ents", async () => {
             await filter.testEnts();
-            verifyLastBeforeCursorQuery(opts.entsLength);
+            verifyLastBeforeCursorQuery(filter, opts.entsLength);
         });
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     test("last. before each cursor", async () => {
-        let [user, contacts] = await (0, test_helpers_1.createAllContacts)();
-        contacts = contacts.reverse();
+        let [user] = await (0, test_helpers_1.createAllContacts)();
         const edges = await opts.newQuery(getViewer(), user).queryEdges();
-        let query;
-        async function verify(i, hasEdge, hasPreviousPage, cursor) {
-            query = opts.newQuery(getViewer(), user);
-            const newEdges = await query.last(1, cursor).queryEdges();
-            const pagination = query.paginationInfo().get(user.id);
-            if (hasEdge) {
-                expect(newEdges.length, `${i}`).toBe(1);
-                expect(newEdges[0], `${i}`).toStrictEqual(edges[i]);
-            }
-            else {
-                expect(newEdges.length, `${i}`).toBe(0);
-            }
-            if (hasPreviousPage) {
-                expect(pagination?.hasPreviousPage).toBe(true);
-                expect(pagination?.hasNextPage).toBe(false);
-            }
-            else {
-                expect(pagination?.hasPreviousPage).toBe(undefined);
-                expect(pagination?.hasNextPage).toBe(undefined);
-            }
-        }
+        const { verify, getCursor } = getVerifyBeforeEachCursor(edges, 1, user);
         await verify(4, true, true, undefined);
-        await verify(3, true, true, query.getCursor(edges[4]));
-        await verify(2, true, true, query.getCursor(edges[3]));
-        await verify(1, true, true, query.getCursor(edges[2]));
-        await verify(0, true, false, query.getCursor(edges[1]));
-        await verify(-1, false, false, query.getCursor(edges[0]));
+        await verify(3, true, true, getCursor(edges[4]));
+        await verify(2, true, true, getCursor(edges[3]));
+        await verify(1, true, true, getCursor(edges[2]));
+        await verify(0, true, false, getCursor(edges[1]));
+        await verify(-1, false, false, getCursor(edges[0]));
+    });
+    describe("with conflicts", () => {
+        let user;
+        let allEdges = [];
+        beforeEach(async () => {
+            const [u, contacts] = await (0, test_helpers_1.createAllContacts)();
+            user = u;
+            const [_, contacts2] = await (0, test_helpers_1.createAllContacts)({
+                user,
+                start: contacts[contacts.length - 1].createdAt.getTime() - 100,
+            });
+            await (0, test_helpers_1.createAllContacts)({
+                user,
+                start: contacts2[contacts.length - 1].createdAt.getTime() - 100,
+            });
+            const edges = await opts.newQuery(getViewer(), user).queryEdges();
+            // confirm there are duplicates...
+            expect(edges[4].created_at).toStrictEqual(edges[5].created_at);
+            expect(edges[9].created_at).toStrictEqual(edges[10].created_at);
+            allEdges = edges;
+        });
+        test("first after each cursor", async () => {
+            const { verify, getCursor } = getVerifyAfterEachCursor(allEdges, 5, user);
+            // regular pagination
+            await verify(0, true, true, undefined);
+            await verify(5, true, true, getCursor(allEdges[4]));
+            await verify(10, true, false, getCursor(allEdges[9]));
+            await verify(15, false, false, getCursor(allEdges[14]));
+            // one without duplicates work if we were paginating at a different place...
+            await verify(6, true, true, getCursor(allEdges[5]));
+            await verify(11, true, false, getCursor(allEdges[10]));
+        });
+        test("last before each cursor", async () => {
+            const { verify, getCursor } = getVerifyBeforeEachCursor(allEdges, 5, user);
+            await verify(14, true, true, undefined);
+            await verify(13, true, true, getCursor(allEdges[14]));
+            await verify(8, true, true, getCursor(allEdges[9]));
+            await verify(9, true, true, getCursor(allEdges[10]));
+            await verify(3, true, false, getCursor(allEdges[4]));
+            await verify(4, true, false, getCursor(allEdges[5]));
+        });
     });
 };
 exports.commonTests = commonTests;