@snowtop/ent 0.1.11 → 0.1.13

package/core/query/shared_assoc_test.js

@@ -12,8 +12,14 @@ 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");
+const query_1 = require("../../testutils/query");
 function assocTests(ml, global = false) {
     ml.mock();
+    // beforeAll(async () => {
+    //   // TODO this is needed when we do only in a test here
+    //   // need to figure this out
+    //   await createEdges();
+    // });
     describe("custom edge", () => {
         let user1, user2;
         beforeEach(async () => {
@@ -58,12 +64,12 @@ function assocTests(ml, global = false) {
         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", "")];
+        const clauses = [(0, clause_1.Eq)("id1", ""), (0, clause_1.Eq)("edge_type", "")];
         if (extraClause) {
-            clses.push(extraClause);
+            clauses.push(extraClause);
         }
         if (global) {
-            clses.push((0, clause_1.Eq)("deleted_at", null));
+            clauses.push((0, clause_1.Eq)("deleted_at", null));
         }
         expect(ml.logs.length).toBe(length);
         for (let i = logsStart; i < numQueries; i++) {
@@ -71,7 +77,7 @@ function assocTests(ml, global = false) {
             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}`);
+            `${(0, clause_1.And)(...clauses).clause(1)} ORDER BY time ${direction}, id2 ${direction} LIMIT ${expLimit}`);
         }
     }
     function verifyCountQuery({ length = 1, numQueries = 1 }) {
@@ -132,7 +138,7 @@ function assocTests(ml, global = false) {
             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);
+                expect(countMap.get(data[0].id)).toBe(test_helpers_1.inputs.length);
             }
             verifyCountQuery({ numQueries: 3, length: 3 });
         }
@@ -141,7 +147,7 @@ function assocTests(ml, global = false) {
             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);
+                expect(countMap.get(data[0].id)).toBe(data[1].length);
             }
             verifyQuery({
                 length: this.dataz.length,
@@ -260,6 +266,34 @@ function assocTests(ml, global = false) {
             await filter.testEnts();
         });
     });
+    function validateQueryIntersectOrUnion(ml, user1, user2) {
+        return function (_query, _cursor) {
+            // 2 queries for user because privacy
+            // 2 queries to fetch edges.
+            expect(ml.logs.length).toBe(4);
+            const where1 = getWhereClause(ml.logs[1]);
+            const clauses1 = [
+                (0, clause_1.Eq)("id1", user1.id),
+                (0, clause_1.Eq)("edge_type", index_1.EdgeType.UserToFriends),
+            ];
+            const clauses2 = [
+                (0, clause_1.Eq)("id1", user2.id),
+                (0, clause_1.Eq)("edge_type", index_1.EdgeType.UserToFriends),
+            ];
+            if (global) {
+                clauses1.push((0, clause_1.Eq)("deleted_at", null));
+                clauses2.push((0, clause_1.Eq)("deleted_at", null));
+            }
+            const clause1 = (0, clause_1.And)(...clauses1);
+            expect(where1).toBe(`${clause1.clause(1)} ORDER BY time DESC LIMIT 1000`);
+            expect(ml.logs[1].values).toStrictEqual(clause1.values());
+            const where2 = getWhereClause(ml.logs[3]);
+            const clause2 = (0, clause_1.And)(...clauses2);
+            // TODO 1001 vs 1000 here
+            expect(where2).toBe(`${clause2.clause(1)} ORDER BY time DESC, id2 DESC LIMIT 1001`);
+            expect(ml.logs[3].values).toStrictEqual(clause2.values());
+        };
+    }
     class ChainTestQueryFilter {
         constructor(initialQuery, subsequentQueries, filter, lastHopFilter) {
             this.initialQuery = initialQuery;
@@ -288,7 +322,7 @@ function assocTests(ml, global = false) {
                     builder.orchestrator.addInboundEdge(this.event2.id, index_1.EdgeType.EventToAttendees, index_1.NodeType.FakeEvent);
                 }
                 await builder.saveX();
-                return await builder.editedEntX();
+                return 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();
@@ -948,6 +982,369 @@ function assocTests(ml, global = false) {
             expect(info2.hasPreviousPage).toBe(false);
         });
     });
+    describe("intersect", () => {
+        let users = [];
+        let user1;
+        let user2;
+        beforeEach(async () => {
+            users = [];
+            for (let i = 0; i < 10; i++) {
+                const user = await (0, test_helpers_1.createTestUser)();
+                users.push(user);
+            }
+            for (let i = 0; i < 10; i++) {
+                const user = users[i];
+                // decreasing number of friends for each user
+                const candidates = users
+                    .slice(0, 10 - i)
+                    .filter((u) => u.id != user.id);
+                await (0, test_helpers_1.addEdge)(user, index_1.FakeUserSchema, index_1.EdgeType.UserToFriends, false, ...candidates);
+                const count = await index_1.UserToFriendsQuery.query(user.viewer, user).queryRawCount();
+                expect(count, `${i}`).toBe(candidates.length);
+            }
+            user1 = users[0];
+            user2 = users[1];
+        });
+        function getQuery() {
+            return index_1.UserToFriendsQuery.query(user1.viewer, user1.id).__intersect(index_1.UserToFriendsQuery.query(user2.viewer, user2.id));
+        }
+        function getCandidateIDs() {
+            // not the first 2 since that's user1 and user2
+            // not the last one since that's removed from user2's list of friends
+            return users.slice(2, users.length - 1).map((u) => u.id);
+        }
+        test("ids", async () => {
+            const ids = await getQuery().queryIDs();
+            const candidates = getCandidateIDs();
+            expect(ids.length).toBe(candidates.length);
+            expect(ids.sort()).toEqual(candidates.sort());
+        });
+        test("count", async () => {
+            const count = await getQuery().queryCount();
+            const candidates = getCandidateIDs();
+            expect(count).toBe(candidates.length);
+        });
+        test("raw_count", async () => {
+            const count = await getQuery().queryRawCount();
+            // raw count doesn't include the intersection
+            expect(count).toBe(users.length - 1);
+        });
+        test("edges", async () => {
+            const edges = await getQuery().queryEdges();
+            const candidates = getCandidateIDs();
+            expect(edges.length).toBe(candidates.length);
+            // for an intersect, the edge returned is always for the source id
+            for (const edge of edges) {
+                expect(edge.id1).toBe(user1.id);
+            }
+        });
+        test("ents", async () => {
+            const ents = await getQuery().queryEnts();
+            const candidates = getCandidateIDs().sort();
+            expect(ents.length).toBe(candidates.length);
+            expect(ents.map((u) => u.id).sort()).toEqual(candidates.sort());
+        });
+        test("first", async () => {
+            const ents = await getQuery().first(2).queryEnts();
+            expect(ents.length).toBe(2);
+        });
+        test("first. after each cursor", async () => {
+            const edges = await getQuery().queryEdges();
+            const { verify, getCursor } = (0, query_1.getVerifyAfterEachCursorGeneric)(edges, 2, user1, getQuery, ml, validateQueryIntersectOrUnion(ml, user1, user2));
+            // this one intentionally not generic so we know where to stop...
+            expect(edges.length).toBe(7);
+            await verify(0, true, true, undefined);
+            await verify(2, true, true, getCursor(edges[1]));
+            await verify(4, true, true, getCursor(edges[3]));
+            // 1 item, no nextPage
+            await verify(6, true, false, getCursor(edges[5]));
+            await verify(7, false, false, getCursor(edges[6]));
+        });
+        test("multiple intersections", async () => {
+            const query = index_1.UserToFriendsQuery.query(user1.viewer, user1.id).__intersect(index_1.UserToFriendsQuery.query(user2.viewer, user2.id), index_1.UserToFriendsQuery.query(user2.viewer, users[2].id), index_1.UserToFriendsQuery.query(user2.viewer, users[3].id));
+            // user0 => 0-9 - self
+            // user1 => 0-8 - self
+            // user2 => 0-7 - self
+            // user3 => 0-6 -self
+            // 7 users - 4 = 3 since you can't be friends with yourself
+            const candidates = [users[4], users[5], users[6]];
+            const [ids, count, edges, ents] = await Promise.all([
+                query.queryIDs(),
+                query.queryCount(),
+                query.queryEdges(),
+                query.queryEnts(),
+            ]);
+            expect(ids.length).toBe(candidates.length);
+            expect(count).toBe(candidates.length);
+            expect(edges.length).toBe(candidates.length);
+            expect(ents.length).toBe(candidates.length);
+            expect(edges.map((e) => e.id2).sort()).toEqual(candidates.map((u) => u.id).sort());
+            expect(ents.map((e) => e.id).sort()).toEqual(candidates.map((u) => u.id).sort());
+        });
+        test("multiple sources", async () => {
+            const query = index_1.UserToFriendsQuery.query(user1.viewer, [
+                user1.id,
+                user2.id,
+            ]).__intersect(index_1.UserToFriendsQuery.query(user2.viewer, users[2].id), index_1.UserToFriendsQuery.query(user2.viewer, users[3].id));
+            // user0 => 0-9 - self
+            // user1 => 0-8 - self
+            // user2 => 0-7 - self
+            // user3 => 0-6 -self
+            // 7 users - 3 = 4 since you can't be friends with yourself
+            // subtracting 3 for each instead of 4 like above because user1 not intersecting with user2
+            const candidates1 = [users[1], users[4], users[5], users[6]];
+            const candidates2 = [users[0], users[4], users[5], users[6]];
+            const [idsMap, countMap, edgesMap, entsMap] = await Promise.all([
+                query.queryAllIDs(),
+                query.queryAllCount(),
+                query.queryAllEdges(),
+                query.queryAllEnts(),
+            ]);
+            async function verify(source, candidates) {
+                const ids = idsMap.get(source.id) ?? [];
+                const count = countMap.get(source.id) ?? [];
+                const edges = edgesMap.get(source.id) ?? [];
+                const ents = entsMap.get(source.id) ?? [];
+                expect(ids.length).toBe(candidates.length);
+                expect(count).toBe(candidates.length);
+                expect(edges.length).toBe(candidates.length);
+                expect(ents.length).toBe(candidates.length);
+                expect(edges.map((e) => e.id2).sort()).toEqual(candidates.map((u) => u.id).sort());
+                expect(ents.map((e) => e.id).sort()).toEqual(candidates.map((u) => u.id).sort());
+            }
+            await verify(user1, candidates1);
+            await verify(user2, candidates2);
+        });
+        test("different edge types", async () => {
+            const event = await (0, test_helpers_1.createTestEvent)(user2);
+            for (let i = 0; i < 5; i++) {
+                const newUser = await (0, test_helpers_1.createTestUser)();
+                await (0, test_helpers_1.addEdge)(event, index_1.FakeEventSchema, index_1.EdgeType.EventToAttendees, false, newUser);
+            }
+            const query = index_1.UserToFriendsQuery.query(user1.viewer, user1.id).__intersect(index_1.EventToAttendeesQuery.query(user1.viewer, event.id));
+            const count = await query.queryCount();
+            expect(count).toBe(0);
+            const candidates = [];
+            for (let i = 0; i < users.length; i++) {
+                const user = users[i];
+                if (user.id !== user1.id && user.id !== user2.id) {
+                    await (0, test_helpers_1.addEdge)(event, index_1.FakeEventSchema, index_1.EdgeType.EventToAttendees, false, user);
+                    candidates.push(user);
+                }
+            }
+            const query2 = index_1.UserToFriendsQuery.query(user1.viewer, user1.id).__intersect(index_1.EventToAttendeesQuery.query(user1.viewer, event.id));
+            const count2 = await query2.queryCount();
+            const ents = await query2.queryEnts();
+            const ids = await query2.queryIDs();
+            expect(count2).toBe(candidates.length);
+            expect(ids.length).toBe(candidates.length);
+            expect(ents.length).toBe(candidates.length);
+            expect(ents.map((e) => e.id).sort()).toEqual(candidates.map((u) => u.id).sort());
+        });
+    });
+    describe("union", () => {
+        let users = [];
+        let user1;
+        let user2;
+        let friends = new Map();
+        beforeEach(async () => {
+            users = [];
+            friends = new Map();
+            for (let i = 0; i < 10; i++) {
+                const user = await (0, test_helpers_1.createTestUser)();
+                users.push(user);
+            }
+            for (let i = 0; i < 10; i++) {
+                const user = users[i];
+                // decreasing number of friends for each user
+                // we want little overlap so new users created.
+                const candidates = users
+                    .slice(0, 10 - i)
+                    .filter((u) => u.id != user.id);
+                // add at least 5 more to each user
+                // every user should end up with 14 or 15
+                // 9 + 5 = 14
+                // 8 + 6 = 14
+                // 7 + 7 = 14
+                // 6 + 8 = 14
+                // 5 + 9 = 14
+                // 4 + 10 = 14
+                // 3 + 11 = 14
+                // 2 + 12 = 14
+                // 1 + 13 = 14
+                // 0 + 14 = 14
+                // 10 original
+                // 5 new for friend 1
+                // 6 new for friend 2
+                const newFriends = await Promise.all(new Array(5 + i).fill(null).map(() => (0, test_helpers_1.createTestUser)()));
+                candidates.push(...newFriends);
+                await (0, test_helpers_1.addEdge)(user, index_1.FakeUserSchema, index_1.EdgeType.UserToFriends, false, ...candidates);
+                const count = await index_1.UserToFriendsQuery.query(user.viewer, user).queryRawCount();
+                expect(count, `${i}`).toBe(candidates.length);
+                friends.set(user.id, candidates);
+            }
+            user1 = users[0];
+            user2 = users[1];
+        });
+        function getQuery() {
+            return index_1.UserToFriendsQuery.query(user1.viewer, user1.id).__union(index_1.UserToFriendsQuery.query(user2.viewer, user2.id));
+        }
+        function getCandidateIDs() {
+            const set = new Set();
+            friends.get(user1.id)?.forEach((u) => set.add(u));
+            friends.get(user2.id)?.forEach((u) => set.add(u));
+            return Array.from(set.values()).map((u) => u.id);
+        }
+        test("ids", async () => {
+            const ids = await getQuery().queryIDs();
+            const candidates = getCandidateIDs();
+            expect(ids.length).toBe(candidates.length);
+            expect(ids.sort()).toEqual(candidates.sort());
+        });
+        test("count", async () => {
+            const count = await getQuery().queryCount();
+            const candidates = getCandidateIDs();
+            expect(count).toBe(candidates.length);
+        });
+        test("raw_count", async () => {
+            const count = await getQuery().queryRawCount();
+            // raw count doesn't include the intersection
+            expect(count).toBe(friends.get(user1.id)?.length);
+        });
+        test("edges", async () => {
+            const edges = await getQuery().queryEdges();
+            const candidates = getCandidateIDs();
+            expect(edges.length).toBe(candidates.length);
+            const idMap = new Map();
+            for (const edge of edges) {
+                const ct = (idMap.get(edge.id1) ?? 0) + 1;
+                idMap.set(edge.id1, ct);
+            }
+            let id1count = friends.get(user1.id)?.length ?? 0;
+            expect(idMap.get(user1.id)).toBe(id1count);
+            expect(idMap.get(user2.id)).toBe(edges.length - id1count);
+        });
+        test("ents", async () => {
+            // only returns privacy aware which is friends + self...
+            const ents = await getQuery().queryEnts();
+            const candidates = getCandidateIDs().sort();
+            let id1count = friends.get(user1.id)?.length ?? 0;
+            const visible = id1count + 1;
+            expect(ents.length).toBe(visible);
+        });
+        test("first", async () => {
+            const ents = await getQuery().first(2).queryEnts();
+            expect(ents.length).toBe(2);
+        });
+        test("first. after each cursor", async () => {
+            const edges = await getQuery().queryEdges();
+            const { verify, getCursor } = (0, query_1.getVerifyAfterEachCursorGeneric)(edges, 3, user1, getQuery, ml, validateQueryIntersectOrUnion(ml, user1, user2));
+            // hardcoded to test
+            expect(edges.length).toBe(21);
+            await verify(0, true, true, undefined);
+            await verify(3, true, true, getCursor(edges[2]));
+            await verify(6, true, true, getCursor(edges[5]));
+            await verify(9, true, true, getCursor(edges[8]));
+            await verify(12, true, true, getCursor(edges[11]));
+            await verify(15, true, true, getCursor(edges[14]));
+            await verify(18, true, true, getCursor(edges[17]));
+            await verify(21, false, false, getCursor(edges[20]));
+        });
+        test("multiple unions", async () => {
+            const user3 = users[2];
+            const user4 = users[3];
+            const query = index_1.UserToFriendsQuery.query(user1.viewer, user1.id).__union(index_1.UserToFriendsQuery.query(user1.viewer, user2.id), index_1.UserToFriendsQuery.query(user1.viewer, user3.id), index_1.UserToFriendsQuery.query(user1.viewer, user4.id));
+            const candidates = Array.from(new Set([
+                ...(friends.get(user1.id) ?? []),
+                ...(friends.get(user2.id) ?? []),
+                ...(friends.get(user3.id) ?? []),
+                ...(friends.get(user4.id) ?? []), // 0-9 (-self) + 8 friends
+            ]).values());
+            // user1 can only see self + friends
+            const user1Visible = friends.get(user1.id) ?? [];
+            user1Visible.push(user1);
+            // should be 36
+            expect(candidates.length).toBe(10 + 5 + 6 + 7 + 8);
+            const [ids, count, edges, ents] = await Promise.all([
+                query.queryIDs(),
+                query.queryCount(),
+                query.queryEdges(),
+                query.queryEnts(),
+            ]);
+            expect(ids.length).toBe(candidates.length);
+            expect(count).toBe(candidates.length);
+            expect(edges.length).toBe(candidates.length);
+            expect(ents.length).toBe(user1Visible.length);
+            expect(edges.map((e) => e.id2).sort()).toEqual(candidates.map((u) => u.id).sort());
+            expect(ents.map((e) => e.id).sort()).toEqual(user1Visible.map((u) => u.id).sort());
+        });
+        test("multiple sources", async () => {
+            const user3 = users[2];
+            const user4 = users[3];
+            const query = index_1.UserToFriendsQuery.query(user1.viewer, [
+                user1.id,
+                user2.id,
+            ]).__union(index_1.UserToFriendsQuery.query(user2.viewer, user3.id), index_1.UserToFriendsQuery.query(user2.viewer, user4.id));
+            const candidates1 = Array.from(new Set([
+                ...(friends.get(user1.id) ?? []),
+                ...(friends.get(user3.id) ?? []),
+                ...(friends.get(user4.id) ?? []), // 0-9 (-self) + 8 friends
+            ]).values());
+            const candidates2 = Array.from(new Set([
+                ...(friends.get(user2.id) ?? []),
+                ...(friends.get(user3.id) ?? []),
+                ...(friends.get(user4.id) ?? []), // 0-9 (-self) + 8 friends
+            ]).values());
+            const [idsMap, countMap, edgesMap, entsMap] = await Promise.all([
+                query.queryAllIDs(),
+                query.queryAllCount(),
+                query.queryAllEdges(),
+                query.queryAllEnts(),
+            ]);
+            // user1 can only see self + friends
+            const user1Visible = friends.get(user1.id) ?? [];
+            user1Visible.push(user1);
+            // since the EntQuery uses user1's viewer
+            // can only see user2's friends that intersect with user1's friends
+            // and that's every user except for the last user since we don't add that user to user2's friends
+            const user2Visible = users.slice(0, users.length - 1);
+            async function verify(source, candidates, visible) {
+                const ids = idsMap.get(source.id) ?? [];
+                const count = countMap.get(source.id) ?? [];
+                const edges = edgesMap.get(source.id) ?? [];
+                const ents = entsMap.get(source.id) ?? [];
+                expect(ids.length).toBe(candidates.length);
+                expect(count).toBe(candidates.length);
+                expect(edges.length).toBe(candidates.length);
+                expect(ents.length).toBe(visible.length);
+                expect(edges.map((e) => e.id2).sort()).toEqual(candidates.map((u) => u.id).sort());
+                expect(ents.map((e) => e.id).sort()).toEqual(visible.map((u) => u.id).sort());
+            }
+            await verify(user1, candidates1, user1Visible);
+            await verify(user2, candidates2, user2Visible);
+        });
+        test("different edge types", async () => {
+            const event = await (0, test_helpers_1.createTestEvent)(user2);
+            const newUsers = [];
+            for (let i = 0; i < 5; i++) {
+                const newUser = await (0, test_helpers_1.createTestUser)();
+                await (0, test_helpers_1.addEdge)(event, index_1.FakeEventSchema, index_1.EdgeType.EventToAttendees, false, newUser);
+                newUsers.push(newUser);
+            }
+            const query = index_1.UserToFriendsQuery.query(user1.viewer, user1.id).__union(index_1.EventToAttendeesQuery.query(user1.viewer, event.id));
+            const candidates = [
+                ...(friends.get(user1.id) ?? []).map((u) => u.id),
+                ...newUsers.map((u) => u.id),
+            ];
+            const count = await query.queryCount();
+            expect(count).toBe(candidates.length);
+            const ents = await query.queryEnts();
+            const ids = await query.queryIDs();
+            expect(ids.length).toBe(candidates.length);
+            // can only see friends
+            expect(ents.length).toBe(friends.get(user1.id)?.length);
+        });
+    });
     if (!global) {
         return;
     }

package/core/query/shared_test.js

@@ -14,13 +14,7 @@ const builder_1 = require("../../testutils/builder");
 const action_1 = require("../../action");
 const clause_1 = require("../clause");
 const query_impl_1 = require("../query_impl");
-function getWhereClause(query) {
-    const idx = query.query.indexOf("WHERE");
-    if (idx !== -1) {
-        return query.query.substr(idx + 6);
-    }
-    return null;
-}
+const query_1 = require("../../testutils/query");
 const commonTests = (opts) => {
     (0, logger_1.setLogLevels)(["query", "error"]);
     const ml = opts.ml;
@@ -152,7 +146,7 @@ const commonTests = (opts) => {
         const uniqCol = isCustomQuery(filter) ? "id" : "id2";
         expect(ml.logs.length).toBe(length);
         for (let i = 0; i < numQueries; i++) {
-            const whereClause = getWhereClause(ml.logs[i]);
+            const whereClause = (0, query_1.getWhereClause)(ml.logs[i]);
             let expLimit = disablePaginationBump ? limit : limit + 1;
             expect(whereClause, `${i}`).toBe(
             // default limit
@@ -162,7 +156,7 @@ const commonTests = (opts) => {
     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]);
+            const whereClause = (0, query_1.getWhereClause)(ml.logs[i]);
             expect(whereClause).toBe(opts.clause.clause(1));
         }
     }
@@ -180,7 +174,7 @@ const commonTests = (opts) => {
         else {
             parts.push(cmp);
         }
-        expect(getWhereClause(ml.logs[0])).toBe(`${parts.join(" AND ")} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(opts.orderby)}, ${uniqCol} ${opts.orderby[0].direction} LIMIT ${limit + 1}`);
+        expect((0, query_1.getWhereClause)(ml.logs[0])).toBe(`${parts.join(" AND ")} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(opts.orderby)}, ${uniqCol} ${opts.orderby[0].direction} LIMIT ${limit + 1}`);
     }
     function verifyLastBeforeCursorQuery(filter, { length = 1, limit = 3, orderby = opts.orderby }) {
         // cache showing up in a few because of cross runs...
@@ -196,7 +190,7 @@ const commonTests = (opts) => {
         else {
             parts.push(cmp);
         }
-        expect(getWhereClause(ml.logs[0])).toBe(
+        expect((0, query_1.getWhereClause)(ml.logs[0])).toBe(
         // extra fetched for pagination
         `${parts.join(" AND ")} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(orderby)}, ${uniqCol} ${orderby[0].direction} LIMIT ${limit + 1}`);
     }
@@ -210,38 +204,16 @@ const commonTests = (opts) => {
         });
     }
     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);
-            }
+        return (0, query_1.getVerifyAfterEachCursorGeneric)(edges, pageLength, user, 
+        // @ts-ignore weirdness with import paths...
+        () => opts.newQuery(getViewer(), user), ml, (query, cursor) => {
             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;

package/core/query_impl.d.ts

@@ -5,6 +5,7 @@ export interface OrderByOption {
     nullsPlacement?: "first" | "last";
 }
 export type OrderBy = OrderByOption[];
-export declare function getOrderByPhrase(orderby: OrderBy): string;
+export declare function getOrderByPhrase(orderby: OrderBy, alias?: string): string;
 export declare function reverseOrderBy(orderby: OrderBy): OrderBy;
+export declare function getJoinPhrase(join: NonNullable<QueryableDataOptions["join"]>, clauseIdx?: number): string;
 export declare function buildQuery(options: QueryableDataOptions): string;

package/core/query_impl.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildQuery = exports.reverseOrderBy = exports.getOrderByPhrase = void 0;
-function getOrderByPhrase(orderby) {
+exports.buildQuery = exports.getJoinPhrase = exports.reverseOrderBy = exports.getOrderByPhrase = void 0;
+function getOrderByPhrase(orderby, alias) {
     return orderby
         .map((v) => {
         let nullsPlacement = "";
@@ -13,7 +13,8 @@ function getOrderByPhrase(orderby) {
                 nullsPlacement = " NULLS LAST";
                 break;
         }
-        return `${v.column} ${v.direction}${nullsPlacement}`;
+        const col = alias ? `${alias}.${v.column}` : v.column;
+        return `${col} ${v.direction}${nullsPlacement}`;
     })
         .join(", ");
 }
@@ -26,17 +27,34 @@ function reverseOrderBy(orderby) {
     });
 }
 exports.reverseOrderBy = reverseOrderBy;
+function getJoinPhrase(join, clauseIdx = 1) {
+    const joinTable = join.alias
+        ? `${join.tableName} ${join.alias}`
+        : join.tableName;
+    return `${joinTable} ON ${join.clause.clause(clauseIdx)}`;
+}
+exports.getJoinPhrase = getJoinPhrase;
 function buildQuery(options) {
-    const fields = options.fields.join(", ");
+    const fields = options.alias
+        ? options.fields.map((f) => `${options.alias}.${f}`).join(", ")
+        : options.fields.join(", ");
     // always start at 1
-    const whereClause = options.clause.clause(1);
     const parts = [];
-    parts.push(`SELECT ${fields} FROM ${options.tableName} WHERE ${whereClause}`);
+    const tableName = options.alias
+        ? `${options.tableName} AS ${options.alias}`
+        : options.tableName;
+    parts.push(`SELECT ${fields} FROM ${tableName}`);
+    let whereStart = 1;
+    if (options.join) {
+        parts.push(`JOIN ${getJoinPhrase(options.join, 1)}`);
+        whereStart += options.join.clause.values().length;
+    }
+    parts.push(`WHERE ${options.clause.clause(whereStart, options.alias)}`);
     if (options.groupby) {
         parts.push(`GROUP BY ${options.groupby}`);
     }
     if (options.orderby) {
-        parts.push(`ORDER BY ${getOrderByPhrase(options.orderby)}`);
+        parts.push(`ORDER BY ${getOrderByPhrase(options.orderby, options.alias)}`);
     }
     if (options.limit) {
         parts.push(`LIMIT ${options.limit}`);

package/graphql/query/edge_connection.js

@@ -49,7 +49,7 @@ class GraphQLEdgeConnection {
         this.query = fn(this.query);
     }
     async queryTotalCount() {
-        return await this.query.queryRawCount();
+        return this.query.queryRawCount();
     }
     async queryEdges() {
         // because of privacy, we need to query the node regardless of if the node is there
@@ -60,7 +60,7 @@ class GraphQLEdgeConnection {
     // if nodes queried just return ents
     // unlikely to query nodes and pageInfo so we just load this separately for now
     async queryNodes() {
-        return await this.query.queryEnts();
+        return this.query.queryEnts();
     }
     defaultPageInfo() {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -21,7 +21,7 @@
     "minimist": "^1.2.8",
     "pascal-case": "^3.1.2",
     "pg": "^8.11.0",
-    "prettier": "^2.8.8",
+    "prettier": "^3.0.3",
     "snake-case": "^3.0.4",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",