@snowtop/ent 0.1.0-alpha160-test7 → 0.1.0-alpha161-test1

package/core/query/shared_assoc_test.js

@@ -0,0 +1,1089 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assocTests = void 0;
+const base_1 = require("../base");
+const ent_1 = require("../ent");
+const viewer_1 = require("../viewer");
+const jest_date_mock_1 = require("jest-date-mock");
+const index_1 = require("../../testutils/fake_data/index");
+const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
+const clause_1 = require("../clause");
+const builder_1 = require("../../testutils/builder");
+const luxon_1 = require("luxon");
+const convert_1 = require("../convert");
+const test_context_1 = require("../../testutils/context/test_context");
+function assocTests(ml, global = false) {
+    ml.mock();
+    describe("custom edge", () => {
+        let user1, user2;
+        beforeEach(async () => {
+            user2 = await (0, test_helpers_1.createTestUser)();
+            const builder = (0, index_1.getUserBuilder)(new viewer_1.LoggedOutViewer(), (0, test_helpers_1.getUserInput)());
+            builder.orchestrator.addOutboundEdge(user2.id, index_1.EdgeType.UserToCustomEdge, index_1.NodeType.FakeUser);
+            await builder.saveX();
+            user1 = await builder.editedEntX();
+        });
+        test("ids", async () => {
+            const ids = await index_1.UserToCustomEdgeQuery.query(user1.viewer, user1).queryIDs();
+            expect(ids.length).toBe(1);
+            expect(ids).toEqual([user2.id]);
+        });
+        test("edges", async () => {
+            const edges = await index_1.UserToCustomEdgeQuery.query(user1.viewer, user1).queryEdges();
+            expect(edges.length).toBe(1);
+            const edge = edges[0];
+            expect(edge).toBeInstanceOf(index_1.CustomEdge);
+            expect(edge.id1).toBe(user1.id);
+            expect(edge.id2).toBe(user2.id);
+            expect(edge.edgeType).toBe(index_1.EdgeType.UserToCustomEdge);
+        });
+        test("id2", async () => {
+            const edge = await index_1.UserToCustomEdgeQuery.query(user1.viewer, user1).queryID2(user2.id);
+            expect(edge).toBeDefined();
+            expect(edge).toBeInstanceOf(index_1.CustomEdge);
+            expect(edge.id1).toBe(user1.id);
+            expect(edge.id2).toBe(user2.id);
+            expect(edge.edgeType).toBe(index_1.EdgeType.UserToCustomEdge);
+        });
+    });
+    const N = 2;
+    function firstNFilter(q) {
+        return q.first(N);
+    }
+    function firstNEntsFilter(contacts) {
+        return contacts.reverse().slice(0, N);
+    }
+    function getWhereClause(query) {
+        let execArray = /^SELECT (.+) FROM (.+) WHERE (.+)?/.exec(query.query);
+        return execArray?.[3];
+    }
+    function verifyQuery({ length = 1, numQueries = 1, limit = (0, ent_1.getDefaultLimit)(), extraClause = undefined, disablePaginationBump = false, logsStart = 0, direction = "DESC", }) {
+        const clses = [(0, clause_1.Eq)("id1", ""), (0, clause_1.Eq)("edge_type", "")];
+        if (extraClause) {
+            clses.push(extraClause);
+        }
+        if (global) {
+            clses.push((0, clause_1.Eq)("deleted_at", null));
+        }
+        expect(ml.logs.length).toBe(length);
+        for (let i = logsStart; i < numQueries; i++) {
+            const whereClause = getWhereClause(ml.logs[i]);
+            let expLimit = disablePaginationBump ? limit : limit + 1;
+            expect(whereClause, `${i}`).toBe(
+            // default limit
+            `${(0, clause_1.And)(...clses).clause(1)} ORDER BY time ${direction}, id2 ${direction} LIMIT ${expLimit}`);
+        }
+    }
+    function verifyCountQuery({ length = 1, numQueries = 1 }) {
+        expect(ml.logs.length).toBe(length);
+        for (let i = 0; i < numQueries; i++) {
+            const whereClause = getWhereClause(ml.logs[i]);
+            if (global) {
+                expect(whereClause).toBe(`${(0, clause_1.And)((0, clause_1.Eq)("id1", ""), (0, clause_1.Eq)("edge_type", ""), (0, clause_1.Eq)("deleted_at", null)).clause(1)}`);
+            }
+            else {
+                expect(whereClause).toBe(`${(0, clause_1.And)((0, clause_1.Eq)("id1", ""), (0, clause_1.Eq)("edge_type", "")).clause(1)}`);
+            }
+        }
+    }
+    // TODO need to test multi-ids with id1s that aren't visible...
+    // so 2 user's friend requests at the same time
+    class MultiIDsTestQueryFilter {
+        constructor(filter, ents, limit) {
+            this.filter = filter;
+            this.ents = ents;
+            this.limit = limit;
+            this.dataz = [];
+        }
+        async beforeEach() {
+            let [user1, user2, user3] = await Promise.all([
+                (0, test_helpers_1.createAllContacts)({ input: { firstName: "Jon", lastName: "Snow" } }),
+                (0, test_helpers_1.createAllContacts)({
+                    input: { firstName: "Aegon", lastName: "Targaryen" },
+                }),
+                (0, test_helpers_1.createAllContacts)({ input: { firstName: "Ned", lastName: "Stark" } }),
+            ]);
+            // modify contacts as needed
+            user1[1] = this.ents(user1[1]);
+            user2[1] = this.ents(user2[1]);
+            user3[1] = this.ents(user3[1]);
+            this.dataz = [user1, user2, user3];
+            ml.clear();
+        }
+        getQuery(viewer) {
+            return this.filter(index_1.UserToContactsQuery.query(viewer || new viewer_1.LoggedOutViewer(), this.dataz.map((data) => data[0])));
+        }
+        async testIDs() {
+            const idsMap = await this.getQuery().queryAllIDs();
+            expect(idsMap.size).toBe(this.dataz.length);
+            for (let i = 0; i < this.dataz.length; i++) {
+                let data = this.dataz[i];
+                expect(idsMap.get(data[0].id)).toEqual(data[1].map((contact) => contact.id));
+            }
+            verifyQuery({
+                length: this.dataz.length,
+                numQueries: this.dataz.length,
+                limit: this.limit || (0, ent_1.getDefaultLimit)(),
+            });
+        }
+        // rawCount isn't affected by filters...
+        async testRawCount() {
+            const countMap = await this.getQuery().queryAllRawCount();
+            expect(countMap.size).toBe(this.dataz.length);
+            for (let i = 0; i < this.dataz.length; i++) {
+                let data = this.dataz[i];
+                expect(countMap.get(data[0].id)).toStrictEqual(test_helpers_1.inputs.length);
+            }
+            verifyCountQuery({ numQueries: 3, length: 3 });
+        }
+        async testCount() {
+            const countMap = await this.getQuery().queryAllCount();
+            expect(countMap.size).toBe(this.dataz.length);
+            for (let i = 0; i < this.dataz.length; i++) {
+                let data = this.dataz[i];
+                expect(countMap.get(data[0].id)).toStrictEqual(data[1].length);
+            }
+            verifyQuery({
+                length: this.dataz.length,
+                numQueries: this.dataz.length,
+                limit: this.limit || (0, ent_1.getDefaultLimit)(),
+            });
+        }
+        async testEdges() {
+            const edgesMap = await this.getQuery().queryAllEdges();
+            expect(edgesMap.size).toBe(this.dataz.length);
+            for (let i = 0; i < this.dataz.length; i++) {
+                let data = this.dataz[i];
+                (0, test_helpers_1.verifyUserToContactEdges)(data[0], edgesMap.get(data[0].id) || [], data[1]);
+            }
+            verifyQuery({
+                length: this.dataz.length,
+                numQueries: this.dataz.length,
+                limit: this.limit || (0, ent_1.getDefaultLimit)(),
+            });
+        }
+        async testEnts() {
+            // privacy...
+            const entsMap = await this.getQuery().queryAllEnts();
+            expect(entsMap.size).toBe(this.dataz.length);
+            for (let i = 0; i < this.dataz.length; i++) {
+                let data = this.dataz[i];
+                (0, test_helpers_1.verifyUserToContacts)(data[0], entsMap.get(data[0].id) || [], []);
+            }
+            // privacy. only data for the first id is visible in this case
+            const entsMap2 = await this.getQuery(new viewer_1.IDViewer(this.dataz[0][0].id)).queryAllEnts();
+            expect(entsMap2.size).toBe(this.dataz.length);
+            for (let i = 0; i < this.dataz.length; i++) {
+                let data = this.dataz[i];
+                (0, test_helpers_1.verifyUserToContacts)(data[0], entsMap2.get(data[0].id) || [], i == 0 ? data[1] : []);
+            }
+            verifyQuery({
+                // extra query for the nodes
+                // dataz.length twice to fetch the edge data
+                // and then twice to fetch all the nodes for the contacts
+                length: this.dataz.length + this.dataz.length + this.dataz.length * 2,
+                numQueries: this.dataz.length,
+                limit: this.limit || (0, ent_1.getDefaultLimit)(),
+            });
+        }
+    }
+    describe("multi-ids", () => {
+        const filter = new MultiIDsTestQueryFilter((q) => {
+            // no filters
+            return q;
+        }, (contacts) => {
+            // nothing to do here
+            // reverse because edges are most recent first
+            return contacts.reverse();
+        });
+        beforeEach(async () => {
+            await filter.beforeEach();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount();
+        });
+        test("count", async () => {
+            await filter.testCount();
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+        });
+        test("id2", async () => {
+            //    const users = filter.dataz.map((data) => data[0]);
+            for (let i = 0; i < filter.dataz.length; i++) {
+                const id1 = filter.dataz[i][0].id;
+                // get user that corresponds to position
+                const query = filter.getQuery(new viewer_1.IDViewer(id1));
+                const id2 = filter.dataz[i][1][0].id;
+                //get first contact for user
+                const m = await query.queryAllID2(id2);
+                for (let j = 0; j < filter.dataz.length; j++) {
+                    const edge = m.get(filter.dataz[j][0].id);
+                    if (i == j) {
+                        expect(edge).toBeDefined();
+                        expect(edge).toBeInstanceOf(ent_1.AssocEdge);
+                        expect(edge.id1).toBe(id1);
+                        expect(edge.id2).toBe(id2);
+                        expect(edge.edgeType).toBe(index_1.EdgeType.UserToContacts);
+                    }
+                    else {
+                        expect(edge).toBeUndefined();
+                    }
+                }
+            }
+        });
+    });
+    describe("multi-ids. firstN", () => {
+        const filter = new MultiIDsTestQueryFilter(firstNFilter, firstNEntsFilter, 2);
+        beforeEach(async () => {
+            await filter.beforeEach();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount();
+        });
+        test("count", async () => {
+            await filter.testCount();
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+        });
+    });
+    class ChainTestQueryFilter {
+        constructor(initialQuery, subsequentQueries, filter, lastHopFilter) {
+            this.initialQuery = initialQuery;
+            this.subsequentQueries = subsequentQueries;
+            this.filter = filter;
+            this.lastHopFilter = lastHopFilter;
+        }
+        async beforeEach() {
+            this.user = await (0, test_helpers_1.createTestUser)();
+            this.event = await (0, test_helpers_1.createTestEvent)(this.user);
+            this.event2 = await (0, test_helpers_1.createTestEvent)(this.user, { title: "Red Wedding" });
+            this.friends = await Promise.all(test_helpers_1.inputs.map(async (input) => {
+                // just to make times deterministic so that tests can consistently work
+                (0, jest_date_mock_1.advanceBy)(100);
+                const builder = (0, index_1.getUserBuilder)(this.user.viewer, (0, test_helpers_1.getUserInput)(input));
+                // add edge from user to contact
+                builder.orchestrator.addOutboundEdge(this.user.id, index_1.EdgeType.UserToFriends, index_1.NodeType.FakeUser, {
+                    time: new Date(), // set time to advanceBy time
+                });
+                // all invited and all attending
+                builder.orchestrator.addInboundEdge(this.event.id, index_1.EdgeType.EventToInvited, "Event");
+                builder.orchestrator.addInboundEdge(this.event.id, index_1.EdgeType.EventToAttendees, index_1.NodeType.FakeEvent);
+                // Robb also attending the red wedding
+                if (input.firstName === "Robb") {
+                    builder.orchestrator.addInboundEdge(this.event2.id, index_1.EdgeType.EventToInvited, index_1.NodeType.FakeEvent);
+                    builder.orchestrator.addInboundEdge(this.event2.id, index_1.EdgeType.EventToAttendees, index_1.NodeType.FakeEvent);
+                }
+                await builder.saveX();
+                return await builder.editedEntX();
+            }));
+            expect(this.friends.length).toBe(test_helpers_1.inputs.length);
+            const count = await index_1.UserToFriendsQuery.query(new viewer_1.IDViewer(this.user.id), this.user.id).queryCount();
+            expect(count).toStrictEqual(test_helpers_1.inputs.length);
+        }
+        getQuery(vc) {
+            return this.filter(new this.initialQuery(vc, this.user.id));
+        }
+        async compare(fn, comparer) {
+            const vc = new viewer_1.IDViewer(this.user.id);
+            const oneHopResult = await fn(this.getQuery(vc));
+            const queries = [this.initialQuery, ...this.subsequentQueries];
+            let last = [this.user.id];
+            let allHopsResult;
+            for (let i = 0; i < queries.length; i++) {
+                let queryCtr = queries[i];
+                let query = new queryCtr(vc, last);
+                if (this.lastHopFilter && i + 1 == queries.length - 1) {
+                    query = this.lastHopFilter(query);
+                }
+                if (i === queries.length - 1) {
+                    allHopsResult = await fn(query);
+                    break;
+                }
+                let result = await query.queryAllIDs();
+                last = [];
+                for (const [_, ids] of result) {
+                    last.push(...ids);
+                }
+            }
+            if (comparer) {
+                comparer(oneHopResult, allHopsResult);
+            }
+            else {
+                expect(oneHopResult).toStrictEqual(allHopsResult);
+            }
+        }
+        async testIDs() {
+            await this.compare((q) => q.queryAllIDs());
+        }
+        async testCount() {
+            await this.compare((q) => q.queryAllCount());
+        }
+        async testRawCount() {
+            await this.compare((q) => q.queryAllRawCount());
+        }
+        async testEdges() {
+            await this.compare((q) => q.queryAllEdges());
+        }
+        async testEnts() {
+            function compare(oneHop, allHops) {
+                expect(allHops.size).toEqual(oneHop.size);
+                for (const [key, ents] of allHops) {
+                    expect(oneHop.has(key)).toEqual(true);
+                    const oneHopEnts = oneHop.get(key);
+                    for (let i = 0; i < ents.length; i++) {
+                        expect(oneHopEnts[i].id).toEqual(ents[i].id);
+                    }
+                }
+            }
+            await this.compare((q) => q.queryAllEnts(), compare);
+        }
+    }
+    describe("chained queries 2 steps", () => {
+        const filter = new ChainTestQueryFilter(index_1.UserToFriendsQuery, [index_1.UserToEventsAttendingQuery], (q) => {
+            return q.queryEventsAttending();
+        });
+        beforeEach(async () => {
+            await filter.beforeEach();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+        });
+        test("count", async () => {
+            await filter.testCount();
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount();
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+        });
+    });
+    describe("chained queries 2 steps w/ filter", () => {
+        const filter = new ChainTestQueryFilter(index_1.UserToFriendsQuery, [index_1.UserToEventsAttendingQuery], (q) => {
+            return q.first(2).queryEventsAttending();
+        }, (q) => {
+            return q.first(2);
+        });
+        beforeEach(async () => {
+            await filter.beforeEach();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+        });
+        test("count", async () => {
+            await filter.testCount();
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount();
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+        });
+    });
+    describe("chained queries 3 steps", () => {
+        const filter = new ChainTestQueryFilter(index_1.UserToFriendsQuery, [index_1.UserToEventsAttendingQuery, index_1.EventToHostsQuery], (q) => {
+            return q.queryEventsAttending().queryHosts();
+        });
+        beforeEach(async () => {
+            await filter.beforeEach();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+        });
+        test("count", async () => {
+            await filter.testCount();
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount();
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+        });
+    });
+    class PolymorphicID2sTestQueryFilter {
+        constructor(filter, ents, limit) {
+            this.filter = filter;
+            this.ents = ents;
+            this.limit = limit;
+            this.users = [];
+            this.events = [];
+        }
+        async beforeEach() {
+            this.users = [];
+            this.events = [];
+            this.user = await (0, test_helpers_1.createTestUser)();
+            for (let i = 0; i < 5; i++) {
+                (0, jest_date_mock_1.advanceBy)(100);
+                const builder = (0, index_1.getUserBuilder)(this.user.viewer, (0, test_helpers_1.getUserInput)());
+                builder.orchestrator.addOutboundEdge(this.user.id, index_1.EdgeType.ObjectToFollowedUsers, index_1.NodeType.FakeUser);
+                await builder.saveX();
+                const user2 = await builder.editedEntX();
+                this.users.push(user2);
+            }
+            for (let i = 0; i < 5; i++) {
+                (0, jest_date_mock_1.advanceBy)(100);
+                const builder = (0, index_1.getEventBuilder)(this.user.viewer, (0, test_helpers_1.getEventInput)(this.user));
+                builder.orchestrator.addOutboundEdge(this.user.id, index_1.EdgeType.ObjectToFollowedUsers, index_1.NodeType.FakeUser);
+                await builder.saveX();
+                const event = await builder.editedEntX();
+                this.events.push(event);
+            }
+            //order is users, then events
+            this.expCount = this.ents([...this.users, ...this.events]).length;
+            ml.clear();
+        }
+        getQuery(viewer) {
+            return this.filter(index_1.UserToFollowingQuery.query(viewer || new viewer_1.IDViewer(this.user.id), this.user));
+        }
+        async testIDs() {
+            const ids = await this.getQuery().queryIDs();
+            expect(ids.length).toBe(this.expCount);
+            const expIDs = this.users
+                .map((user) => user.id)
+                .concat(this.events.map((event) => event.id))
+                .reverse();
+            expect(expIDs).toEqual(ids);
+            verifyQuery({
+                length: 1,
+                numQueries: 1,
+                limit: this.limit || (0, ent_1.getDefaultLimit)(),
+            });
+        }
+        // rawCount isn't affected by filters...
+        async testRawCount() {
+            const count = await this.getQuery().queryRawCount();
+            expect(count).toBe(this.expCount);
+            verifyCountQuery({ numQueries: 1, length: 1 });
+        }
+        async testCount() {
+            const count = await this.getQuery().queryCount();
+            expect(count).toBe(this.expCount);
+            verifyQuery({
+                length: 1,
+                numQueries: 1,
+                limit: this.limit || (0, ent_1.getDefaultLimit)(),
+            });
+        }
+        async testEdges() {
+            const edges = await this.getQuery().queryEdges();
+            expect(edges.length).toBe(this.expCount);
+            let userCount = 0;
+            let eventCount = 0;
+            edges.forEach((edge) => {
+                if (edge.id2Type === index_1.NodeType.FakeEvent) {
+                    eventCount++;
+                }
+                if (edge.id2Type === index_1.NodeType.FakeUser) {
+                    userCount++;
+                }
+            });
+            expect(userCount).toBe(this.expCount / 2);
+            expect(eventCount).toBe(this.expCount / 2);
+            verifyQuery({
+                length: 1,
+                numQueries: 1,
+                limit: this.limit || (0, ent_1.getDefaultLimit)(),
+            });
+        }
+        async testEnts() {
+            // privacy...
+            const ents = await this.getQuery().queryEnts();
+            expect(ents.length).toBe(this.expCount);
+            let userCount = 0;
+            let eventCount = 0;
+            ents.forEach((ent) => {
+                if (ent instanceof index_1.FakeEvent) {
+                    eventCount++;
+                }
+                if (ent instanceof index_1.FakeUser) {
+                    userCount++;
+                }
+            });
+            expect(userCount).toBe(this.expCount / 2);
+            expect(eventCount).toBe(this.expCount / 2);
+            // when doing privacy checks, hard to say what will be fetched
+            // verifyQuery({
+            //   // 1 for edges, 1 for users, 1 for events
+            //   length: 3,
+            //   numQueries: 3,
+            //   limit: this.limit || getDefaultLimit(),
+            // });
+        }
+    }
+    describe("polymorphic id2s", () => {
+        const filter = new PolymorphicID2sTestQueryFilter((q) => {
+            // no filters
+            return q;
+        }, (ents) => {
+            // nothing to do here
+            // reverse because edges are most recent first
+            return ents.reverse();
+        });
+        // TODO not working when it's a beforeAll
+        // working with beforeEach but we should only need to create this data once
+        beforeEach(async () => {
+            await filter.beforeEach();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount();
+        });
+        test("count", async () => {
+            await filter.testCount();
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+        });
+    });
+    describe("privacy", () => {
+        let user;
+        let friendRequests;
+        let user2;
+        beforeEach(async () => {
+            [user, friendRequests] = await (0, test_helpers_1.createUserPlusFriendRequests)();
+            user2 = await (0, test_helpers_1.createTestUser)();
+        });
+        function getQuery(viewer) {
+            return index_1.UserToIncomingFriendRequestsQuery.query(viewer, user.id);
+        }
+        test("ids", async () => {
+            const ids = await getQuery(user2.viewer).queryIDs();
+            expect(ids.length).toBe(0);
+            const idsFromUser = await getQuery(user.viewer).queryIDs();
+            expect(idsFromUser.length).toBe(friendRequests.length);
+        });
+        test("count", async () => {
+            const count = await getQuery(user2.viewer).queryCount();
+            expect(count).toBe(0);
+            const countFromUser = await getQuery(user.viewer).queryCount();
+            expect(countFromUser).toBe(friendRequests.length);
+        });
+        test("rawCount", async () => {
+            const rawCount = await getQuery(user2.viewer).queryRawCount();
+            expect(rawCount).toBe(0);
+            const rawCountFromUser = await getQuery(user.viewer).queryRawCount();
+            expect(rawCountFromUser).toBe(friendRequests.length);
+        });
+        test("edges", async () => {
+            const edges = await getQuery(user2.viewer).queryEdges();
+            expect(edges.length).toBe(0);
+            const edgesFromUser = await getQuery(user.viewer).queryEdges();
+            expect(edgesFromUser.length).toBe(friendRequests.length);
+        });
+        test("ents", async () => {
+            const ents = await getQuery(user2.viewer).queryEnts();
+            expect(ents.length).toBe(0);
+            const entsFromUser = await getQuery(user.viewer).queryEnts();
+            expect(entsFromUser.length).toBe(0);
+            const entsFromUserVCToken = await getQuery(new index_1.ViewerWithAccessToken(user.id, {
+                tokens: {
+                    allow_incoming_friend_request: true,
+                },
+            })).queryEnts();
+            expect(entsFromUserVCToken.length).toBe(friendRequests.length);
+        });
+    });
+    describe("multi-ids privacy", () => {
+        let user;
+        let friendRequests;
+        let user2;
+        beforeEach(async () => {
+            [user, friendRequests] = await (0, test_helpers_1.createUserPlusFriendRequests)();
+            [user2] = await (0, test_helpers_1.createUserPlusFriendRequests)();
+        });
+        function getQuery(viewer) {
+            return index_1.UserToIncomingFriendRequestsQuery.query(viewer || user.viewer, [
+                user.id,
+                user2.id,
+            ]);
+        }
+        test("ids", async () => {
+            const idsMap = await getQuery().queryAllIDs();
+            expect(idsMap.size).toBe(2);
+            expect(idsMap.get(user.id)?.length).toBe(friendRequests.length);
+            expect(idsMap.get(user2.id)?.length).toBe(0);
+        });
+        test("count", async () => {
+            const countMap = await getQuery().queryAllCount();
+            expect(countMap.size).toBe(2);
+            expect(countMap.get(user.id)).toBe(friendRequests.length);
+            expect(countMap.get(user2.id)).toBe(0);
+        });
+        test("raw count", async () => {
+            const countMap = await getQuery().queryAllRawCount();
+            expect(countMap.size).toBe(2);
+            expect(countMap.get(user.id)).toBe(friendRequests.length);
+            expect(countMap.get(user2.id)).toBe(0);
+        });
+        test("edges", async () => {
+            const edgesMap = await getQuery().queryAllEdges();
+            expect(edgesMap.size).toBe(2);
+            expect(edgesMap.get(user.id)?.length).toBe(friendRequests.length);
+            expect(edgesMap.get(user2.id)?.length).toBe(0);
+        });
+        test("ents", async () => {
+            const entsMap = await getQuery().queryAllEnts();
+            expect(entsMap.size).toBe(2);
+            expect(entsMap.get(user.id)?.length).toBe(0);
+            expect(entsMap.get(user2.id)?.length).toBe(0);
+            const entsMapFromUserVCToken = await getQuery(new index_1.ViewerWithAccessToken(user.id, {
+                tokens: {
+                    allow_incoming_friend_request: true,
+                },
+            })).queryAllEnts();
+            expect(entsMapFromUserVCToken.size).toBe(2);
+            expect(entsMapFromUserVCToken.get(user.id)?.length).toBe(friendRequests.length);
+            expect(entsMapFromUserVCToken.get(user2.id)?.length).toBe(0);
+        });
+    });
+    describe("time based queries", () => {
+        let user;
+        let contacts;
+        let ctx;
+        beforeEach(async () => {
+            ctx = new test_context_1.TestContext();
+            [user, contacts] = await (0, test_helpers_1.createAllContacts)({ ctx });
+            const sortedTimes = contacts.map((c) => c.createdAt.getTime());
+            expect(sortedTimes[1] - sortedTimes[0]).toBe(86400);
+            expect(contacts.length).toBe(5);
+            ml.clear();
+            // to prime the cache
+            await index_1.FakeUser.load(user.viewer, user.id);
+        });
+        function getQuery(viewer) {
+            return index_1.UserToContactsQuery.query(viewer, user.id);
+        }
+        test("ids", async () => {
+            const ids = await getQuery(user.viewer).queryIDs();
+            expect(ids.length).toBe(contacts.length);
+        });
+        test("before", async () => {
+            const ids = await getQuery(user.viewer)
+                .__beforeBETA(contacts[2].createdAt)
+                .queryIDs();
+            expect(ids.length).toBe(2);
+            expect(ids).toEqual([contacts[1].id, contacts[0].id]);
+            verifyQuery({
+                length: 2,
+                extraClause: (0, clause_1.Less)("time", contacts[2].createdAt),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+        });
+        test("before + first", async () => {
+            const ids = await getQuery(user.viewer)
+                .__beforeBETA(contacts[2].createdAt)
+                .first(1)
+                .queryIDs();
+            expect(ids.length).toBe(1);
+            expect(ids).toEqual([contacts[1].id]);
+            verifyQuery({
+                length: 2,
+                limit: 1,
+                extraClause: (0, clause_1.Less)("time", contacts[2].createdAt),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+        });
+        test("before + last", async () => {
+            const ids = await getQuery(user.viewer)
+                .__beforeBETA(contacts[2].createdAt)
+                .last(1)
+                .queryIDs();
+            expect(ids.length).toBe(1);
+            expect(ids).toEqual([contacts[0].id]);
+            verifyQuery({
+                length: 2,
+                limit: 1,
+                extraClause: (0, clause_1.Less)("time", contacts[2].createdAt),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+                direction: "ASC",
+            });
+        });
+        test("before + first with pagination", async () => {
+            const query = getQuery(user.viewer);
+            const edges = await query
+                .__beforeBETA(contacts[2].createdAt)
+                .first(1)
+                .queryEdges();
+            const pagination = query.paginationInfo();
+            expect(edges.length).toBe(1);
+            expect(edges.map((edge) => edge.id2)).toEqual([contacts[1].id]);
+            verifyQuery({
+                length: 2,
+                limit: 1,
+                extraClause: (0, clause_1.Less)("time", contacts[2].createdAt),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+            const info = pagination.get(user.id);
+            expect(info.hasNextPage).toBe(true);
+            expect(info.hasPreviousPage).toBe(false);
+            ml.clear();
+            const query2 = getQuery(user.viewer);
+            const edges2 = await query2
+                .__beforeBETA(contacts[2].createdAt)
+                .first(1, info.endCursor)
+                .queryEdges();
+            const pagination2 = query2.paginationInfo();
+            expect(edges2.length).toBe(1);
+            expect(edges2.map((edge) => edge.id2)).toEqual([contacts[0].id]);
+            // complicated pagination query. ignore verifying for now
+            // verifyFirstAfterCursorQuery in shared_test handles this...
+            const info2 = pagination2.get(user.id) ?? {
+                hasNextPage: false,
+                hasPreviousPage: false,
+            };
+            expect(info2.hasNextPage).toBe(false);
+            expect(info2.hasPreviousPage).toBe(false);
+        });
+        test("after", async () => {
+            const ids = await getQuery(user.viewer)
+                .__afterBETA(contacts[2].createdAt)
+                .queryIDs();
+            expect(ids.length).toBe(2);
+            expect(ids).toEqual([contacts[4].id, contacts[3].id]);
+            verifyQuery({
+                length: 2,
+                extraClause: (0, clause_1.Greater)("time", contacts[2].createdAt),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+        });
+        test("after + first", async () => {
+            const ids = await getQuery(user.viewer)
+                .__afterBETA(contacts[2].createdAt)
+                .first(1)
+                .queryIDs();
+            expect(ids.length).toBe(1);
+            expect(ids).toEqual([contacts[4].id]);
+            verifyQuery({
+                length: 2,
+                limit: 1,
+                extraClause: (0, clause_1.Greater)("time", contacts[2].createdAt),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+        });
+        test("after + last", async () => {
+            const ids = await getQuery(user.viewer)
+                .__afterBETA(contacts[2].createdAt)
+                .last(1)
+                .queryIDs();
+            expect(ids.length).toBe(1);
+            expect(ids).toEqual([contacts[3].id]);
+            verifyQuery({
+                length: 2,
+                limit: 1,
+                extraClause: (0, clause_1.Greater)("time", contacts[2].createdAt),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+                direction: "ASC",
+            });
+        });
+        test("within", async () => {
+            const ids = await getQuery(user.viewer)
+                .__withinBeta(contacts[1].createdAt, contacts[4].createdAt)
+                .queryIDs();
+            expect(ids.length).toBe(3);
+            expect(ids).toEqual([contacts[3].id, contacts[2].id, contacts[1].id]);
+            verifyQuery({
+                length: 2,
+                extraClause: (0, clause_1.And)((0, clause_1.GreaterEq)("time", contacts[1].createdAt), (0, clause_1.Less)("time", contacts[4].createdAt)),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+        });
+        test("within + first", async () => {
+            const ids = await getQuery(user.viewer)
+                .__withinBeta(contacts[1].createdAt, contacts[4].createdAt)
+                .first(2)
+                .queryIDs();
+            expect(ids.length).toBe(2);
+            expect(ids).toEqual([contacts[3].id, contacts[2].id]);
+            verifyQuery({
+                length: 2,
+                limit: 2,
+                extraClause: (0, clause_1.And)((0, clause_1.GreaterEq)("time", contacts[1].createdAt), (0, clause_1.Less)("time", contacts[4].createdAt)),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+        });
+        test("within + last", async () => {
+            const ids = await getQuery(user.viewer)
+                .__withinBeta(contacts[1].createdAt, contacts[4].createdAt)
+                .last(2)
+                .queryIDs();
+            expect(ids.length).toBe(2);
+            expect(ids).toEqual([contacts[1].id, contacts[2].id]);
+            verifyQuery({
+                length: 2,
+                limit: 2,
+                extraClause: (0, clause_1.And)((0, clause_1.GreaterEq)("time", contacts[1].createdAt), (0, clause_1.Less)("time", contacts[4].createdAt)),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+                direction: "ASC",
+            });
+        });
+        test("within + first with pagination", async () => {
+            const query = getQuery(user.viewer);
+            const edges = await query
+                .__withinBeta(contacts[1].createdAt, contacts[4].createdAt)
+                .first(2)
+                .queryEdges();
+            const pagination = query.paginationInfo();
+            expect(edges.length).toBe(2);
+            expect(edges.map((edge) => edge.id2)).toEqual([
+                contacts[3].id,
+                contacts[2].id,
+            ]);
+            verifyQuery({
+                length: 2,
+                limit: 2,
+                extraClause: (0, clause_1.And)((0, clause_1.GreaterEq)("time", contacts[1].createdAt), (0, clause_1.Less)("time", contacts[4].createdAt)),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+            });
+            const info = pagination.get(user.id);
+            expect(info.hasNextPage).toBe(true);
+            expect(info.hasPreviousPage).toBe(false);
+            ml.clear();
+            const query2 = getQuery(user.viewer);
+            const edges2 = await query2
+                .__withinBeta(contacts[1].createdAt, contacts[4].createdAt)
+                .first(2, info.endCursor)
+                .queryEdges();
+            const pagination2 = query2.paginationInfo();
+            expect(edges2.length).toBe(1);
+            expect(edges2.map((edge) => edge.id2)).toEqual([contacts[1].id]);
+            // complicated pagination query. ignore verifying for now
+            // verifyFirstAfterCursorQuery in shared_test handles this...
+            const info2 = pagination2.get(user.id) ?? {
+                hasNextPage: false,
+                hasPreviousPage: false,
+            };
+            expect(info2.hasNextPage).toBe(false);
+            expect(info2.hasPreviousPage).toBe(false);
+        });
+        test("within + last with pagination", async () => {
+            const query = getQuery(user.viewer);
+            const edges = await query
+                .__withinBeta(contacts[1].createdAt, contacts[4].createdAt)
+                .last(2)
+                .queryEdges();
+            const pagination = query.paginationInfo();
+            expect(edges.length).toBe(2);
+            expect(edges.map((edge) => edge.id2)).toEqual([
+                contacts[1].id,
+                contacts[2].id,
+            ]);
+            verifyQuery({
+                length: 2,
+                limit: 2,
+                extraClause: (0, clause_1.And)((0, clause_1.GreaterEq)("time", contacts[1].createdAt), (0, clause_1.Less)("time", contacts[4].createdAt)),
+                // there's a load for user we don't care about here so just skip it...
+                logsStart: 1,
+                numQueries: 2,
+                direction: "ASC",
+            });
+            const info = pagination.get(user.id);
+            expect(info.hasNextPage).toBe(false);
+            expect(info.hasPreviousPage).toBe(true);
+            ml.clear();
+            const query2 = getQuery(user.viewer);
+            const edges2 = await query2
+                .__withinBeta(contacts[1].createdAt, contacts[4].createdAt)
+                .last(2, info.endCursor)
+                .queryEdges();
+            const pagination2 = query2.paginationInfo();
+            expect(edges2.length).toBe(1);
+            expect(edges2.map((edge) => edge.id2)).toEqual([contacts[3].id]);
+            // complicated pagination query. ignore verifying for now
+            // verifyFirstAfterCursorQuery in shared_test handles this...
+            const info2 = pagination2.get(user.id) ?? {
+                hasNextPage: false,
+                hasPreviousPage: false,
+            };
+            expect(info2.hasNextPage).toBe(false);
+            expect(info2.hasPreviousPage).toBe(false);
+        });
+    });
+    if (!global) {
+        return;
+    }
+    // global only tests here
+    describe("deleted edges", () => {
+        let user;
+        let friendRequests;
+        let user2;
+        let postDeletedCount;
+        beforeEach(async () => {
+            [user, friendRequests] = await (0, test_helpers_1.createUserPlusFriendRequests)();
+            user2 = await (0, test_helpers_1.createTestUser)();
+            postDeletedCount = Math.floor(friendRequests.length / 2);
+        });
+        async function deleteEdges() {
+            const action = new builder_1.SimpleAction(user.viewer, index_1.FakeUserSchema, new Map(), base_1.WriteOperation.Edit, user);
+            for (let i = 0; i < friendRequests.length; i++) {
+                if (i % 2 == 0) {
+                    action.builder.orchestrator.removeInboundEdge(friendRequests[i].id, index_1.EdgeType.UserToFriendRequests);
+                }
+            }
+            await action.saveX();
+        }
+        function getQuery(viewer) {
+            return index_1.UserToIncomingFriendRequestsQuery.query(viewer, user.id);
+        }
+        test("ids", async () => {
+            const ids = await getQuery(user.viewer).queryIDs();
+            expect(ids.length).toBe(friendRequests.length);
+        });
+        test("ids after deleted", async () => {
+            await deleteEdges();
+            const idsFromUser = await getQuery(user.viewer).queryIDs();
+            expect(idsFromUser.length).toBe(postDeletedCount);
+        });
+        test("ids deleted. fetch deleted anyways", async () => {
+            await deleteEdges();
+            const idsFromUser = await getQuery(user.viewer)
+                .withoutTransformations()
+                .queryIDs();
+            expect(idsFromUser.length).toBe(friendRequests.length);
+        });
+        test("count", async () => {
+            const count = await getQuery(user.viewer).queryCount();
+            expect(count).toBe(friendRequests.length);
+        });
+        test("count after deleted", async () => {
+            await deleteEdges();
+            const count = await getQuery(user.viewer).queryCount();
+            expect(count).toBe(postDeletedCount);
+        });
+        test("count after deleted. fetch deleted", async () => {
+            await deleteEdges();
+            const count = await getQuery(user.viewer)
+                .withoutTransformations()
+                .queryCount();
+            expect(count).toBe(friendRequests.length);
+        });
+        test("raw count", async () => {
+            const count = await getQuery(user.viewer).queryCount();
+            expect(count).toBe(friendRequests.length);
+        });
+        test("raw count after deleted", async () => {
+            await deleteEdges();
+            const count = await getQuery(user.viewer).queryRawCount();
+            expect(count).toBe(postDeletedCount);
+        });
+        test("raw count after deleted. fetch deleted", async () => {
+            await deleteEdges();
+            const count = await getQuery(user.viewer)
+                .withoutTransformations()
+                .queryRawCount();
+            expect(count).toBe(friendRequests.length);
+        });
+        test("edges", async () => {
+            const edges = await getQuery(user.viewer).queryEdges();
+            expect(edges.length).toBe(friendRequests.length);
+            for (const edge of edges) {
+                expect(edge.deleted_at).toBeNull();
+            }
+        });
+        test("edges after deleted", async () => {
+            await deleteEdges();
+            const edges = await getQuery(user.viewer).queryEdges();
+            expect(edges.length).toBe(postDeletedCount);
+            for (const edge of edges) {
+                expect(edge.deleted_at).toBeNull();
+            }
+        });
+        test("edges after deleted. fetch deleted", async () => {
+            await deleteEdges();
+            const edges = await getQuery(user.viewer)
+                .withoutTransformations()
+                .queryEdges();
+            expect(edges.length).toBe(friendRequests.length);
+            let notDeletedAtCt = 0;
+            for (const edge of edges) {
+                if (edge.deleted_at === null) {
+                    notDeletedAtCt++;
+                }
+                else {
+                    expect(luxon_1.DateTime.fromJSDate((0, convert_1.convertDate)(edge.deleted_at)).isValid).toBe(true);
+                }
+            }
+            expect(notDeletedAtCt).toBe(postDeletedCount);
+        });
+        test("ents", async () => {
+            const viewer = new index_1.ViewerWithAccessToken(user.id, {
+                tokens: {
+                    allow_incoming_friend_request: true,
+                },
+            });
+            const ents = await getQuery(viewer).queryEnts();
+            expect(ents.length).toBe(friendRequests.length);
+        });
+        test("ents after deleted", async () => {
+            await deleteEdges();
+            const viewer = new index_1.ViewerWithAccessToken(user.id, {
+                tokens: {
+                    allow_incoming_friend_request: true,
+                },
+            });
+            const ents = await getQuery(viewer).queryEnts();
+            expect(ents.length).toBe(postDeletedCount);
+        });
+        test("ents after deleted. fetch deleted", async () => {
+            await deleteEdges();
+            const viewer = new index_1.ViewerWithAccessToken(user.id, {
+                tokens: {
+                    allow_incoming_friend_request: true,
+                    always_allow_user: true,
+                },
+            });
+            const ents = await getQuery(viewer).withoutTransformations().queryEnts();
+            expect(ents.length).toBe(friendRequests.length);
+        });
+    });
+}
+exports.assocTests = assocTests;