@snowtop/ent 0.2.0-alpha.6.test → 0.2.0-alpha.7

package/core/query/query.js

@@ -27,59 +27,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEdgeQuery = void 0;
-const ent_1 = require("../ent");
-const clause = __importStar(require("../clause"));
 const memoizee_1 = __importDefault(require("memoizee"));
+const types_1 = require("util/types");
+const clause = __importStar(require("../clause"));
+const ent_1 = require("../ent");
 const privacy_1 = require("../privacy");
-const uuid_1 = require("uuid");
 const query_impl_1 = require("../query_impl");
-const types_1 = require("util/types");
 // TODO can we generalize EdgeQuery to support any clause
 function assertPositive(n) {
     if (n < 0) {
         throw new Error("cannot use a negative number");
     }
 }
-function convertToIntMaybe(val) {
-    // TODO handle both cases... (time vs not) better
-    // TODO change this to only do the parseInt part if time...
-    // pass flag indicating if time?
-    // handle non-integers for which the first part is an int
-    // @ts-ignore
-    if (isNaN(val)) {
-        return val;
+function translateCursorToKeyValues(cursor, opts) {
+    const { keys } = opts;
+    const decoded = atob(cursor);
+    let cursorData = [];
+    try {
+        cursorData = JSON.parse(decoded);
     }
-    const time = parseInt(val, 10);
-    if (isNaN(time)) {
-        return val;
+    catch (error) {
+        throw new Error(`Bad cursor format ${cursor} passed`);
     }
-    return time;
-}
-function assertValidCursor(cursor, opts) {
-    let decoded = Buffer.from(cursor, "base64").toString("ascii");
-    let parts = decoded.split(":");
-    const { keys } = opts;
     // invalid or unknown cursor. nothing to do here.
-    // we should have the same number of parts as keys * 2
-    if (parts.length !== keys.length * 2) {
+    // we should have the same number of parts as keys
+    if (cursorData.length !== keys.length) {
         throw new Error(`invalid cursor ${cursor} passed`);
     }
-    const values = [];
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const keyPart = parts[i * 2];
-        if (key !== keyPart) {
-            throw new Error(`invalid cursor ${cursor} passed. expected ${key}. got ${keyPart} as key of field`);
-        }
-        const val = parts[i * 2 + 1];
-        // uuid, don't parse int since it tries to validate just first part
-        if ((0, uuid_1.validate)(val)) {
-            values.push(val);
-            continue;
-        }
-        values.push(convertToIntMaybe(val));
-    }
-    return values;
+    return cursorData;
 }
 const orderbyRegex = new RegExp(/([0-9a-z_]+)[ ]?([0-9a-z_]+)?/i);
 class FirstFilter {
@@ -87,14 +62,14 @@ class FirstFilter {
         this.options = options;
         this.pageMap = new Map();
         this.usedQuery = false;
-        this.cursorValues = [];
+        this.cursorKeyValues = [];
         assertPositive(options.limit);
-        this.sortCol = options.sortCol;
         if (options.after) {
-            this.cursorValues = assertValidCursor(options.after, {
+            this.cursorKeyValues = translateCursorToKeyValues(options.after, {
                 keys: options.cursorKeys,
             });
-            this.offset = this.cursorValues[0];
+            this.offset =
+                this.cursorKeyValues[this.cursorKeyValues.length - 1][1] ?? undefined;
         }
         this.edgeQuery = options.query;
     }
@@ -158,58 +133,25 @@ class FirstFilter {
         // so we'd need a way to indicate whether this is done in sql or not
         return edges;
     }
-    getOffsetForQuery() {
-        // cursorCol maps to offset which we get from the cursor in assertValidCursor
-        return this.options.cursorColIsDate
-            ? new Date(this.offset).toISOString()
-            : this.offset;
-    }
-    getSortValueForQuery() {
-        // sortCol maps to the value we're comparing against
-        return this.options.sortColIsDate
-            ? new Date(this.cursorValues[1]).toISOString()
-            : this.cursorValues[1];
-    }
     async query(options) {
         this.usedQuery = true;
         // we fetch an extra one to see if we're at the end
-        const limit = this.options.limit + 1;
-        options.limit = limit;
-        // we sort by most recent first
-        // so when paging, we fetch afterCursor X
-        const less = this.options.orderby[0].direction === "DESC";
-        const orderby = this.options.orderby;
-        if (this.options.cursorCol !== this.sortCol) {
-            // we also sort cursor col in same direction. (direction doesn't matter)
-            orderby.push({
-                column: this.options.cursorCol,
-                direction: orderby[0].direction,
-            });
-            if (this.offset) {
-                const res = this.edgeQuery.getTableName();
-                let tableName = (0, types_1.isPromise)(res) ? await res : res;
-                // using a join, we already know sortCol and cursorCol are different
-                // we have encoded both values in the cursor
-                // includeSortColInCursor() is true in this case
-                if (this.cursorValues.length === 2 &&
-                    this.options.cursorKeys.length === 2) {
-                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsQuery(this.sortCol, this.options.cursorCol, less, this.getSortValueForQuery(), this.getOffsetForQuery(), this.options.fieldOptions?.fieldsAlias ??
-                        this.options.fieldOptions?.alias));
-                }
-                else {
-                    // inner col time
-                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.getOffsetForQuery()));
-                }
-            }
-        }
-        else {
-            if (this.offset) {
-                const clauseFn = less ? clause.Less : clause.Greater;
-                const val = this.getOffsetForQuery();
-                options.clause = clause.AndOptional(options.clause, clauseFn(this.sortCol, val));
+        options.limit = this.options.limit + 1;
+        const orderBy = this.options.orderby;
+        if (this.offset) {
+            const keyValuePairs = {};
+            for (const [key, value] of this.cursorKeyValues) {
+                keyValuePairs[key] = value;
             }
+            options.clause = clause.AndOptional(options.clause, clause.PaginationUnboundColsQuery(orderBy.map((orderBy) => ({
+                sortCol: orderBy.column,
+                sortValue: keyValuePairs[orderBy.column],
+                direction: orderBy.direction,
+                nullsPlacement: orderBy.nullsPlacement,
+                overrideAlias: orderBy.alias,
+            }))));
         }
-        options.orderby = orderby;
+        options.orderby = orderBy;
         return options;
     }
     // TODO?
@@ -223,14 +165,14 @@ class LastFilter {
     constructor(options) {
         this.options = options;
         this.pageMap = new Map();
-        this.cursorValues = [];
+        this.cursorKeyValues = [];
         assertPositive(options.limit);
-        this.sortCol = options.sortCol;
         if (options.before) {
-            this.cursorValues = assertValidCursor(options.before, {
+            this.cursorKeyValues = translateCursorToKeyValues(options.before, {
                 keys: options.cursorKeys,
             });
-            this.offset = this.cursorValues[0];
+            this.offset =
+                this.cursorKeyValues[this.cursorKeyValues.length - 1][1] ?? undefined;
         }
         this.edgeQuery = options.query;
     }
@@ -261,56 +203,25 @@ class LastFilter {
         }
         return ret;
     }
-    // copied from FirstFilter
-    getOffsetForQuery() {
-        // cursorCol maps to offset which we get from the cursor in assertValidCursor
-        return this.options.cursorColIsDate
-            ? new Date(this.offset).toISOString()
-            : this.offset;
-    }
-    getSortValueForQuery() {
-        // sortCol maps to the value we're comparing against
-        return this.options.sortColIsDate
-            ? new Date(this.cursorValues[1]).toISOString()
-            : this.cursorValues[1];
-    }
     async query(options) {
-        const orderby = (0, query_impl_1.reverseOrderBy)(this.options.orderby);
-        const greater = orderby[0].direction === "ASC";
-        options.limit = this.options.limit + 1; // fetch an extra so we know if previous pag
-        if (this.options.cursorCol !== this.sortCol) {
-            const res = this.edgeQuery.getTableName();
-            const tableName = (0, types_1.isPromise)(res) ? await res : res;
-            if (this.offset) {
-                // using a join, we already know sortCol and cursorCol are different
-                // we have encoded both values in the cursor
-                // includeSortColInCursor() is true in this case
-                if (this.cursorValues.length === 2 &&
-                    this.options.cursorKeys.length === 2) {
-                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsQuery(this.sortCol, this.options.cursorCol, 
-                    // flipped here since we're going in the opposite direction
-                    !greater, this.getSortValueForQuery(), this.getOffsetForQuery(), this.options.fieldOptions?.fieldsAlias ??
-                        this.options.fieldOptions?.alias));
-                }
-                else {
-                    // inner col time
-                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, greater ? ">" : "<", tableName, this.options.cursorCol, this.getOffsetForQuery()));
-                }
-            }
-            // we also sort cursor col in same direction. (direction doesn't matter)
-            orderby.push({
-                column: this.options.cursorCol,
-                direction: orderby[0].direction,
-            });
-        }
-        else {
-            if (this.offset) {
-                const clauseFn = greater ? clause.Greater : clause.Less;
-                const val = this.getOffsetForQuery();
-                options.clause = clause.AndOptional(options.clause, clauseFn(this.sortCol, val));
+        // we fetch an extra one to see if we're at the end
+        options.limit = this.options.limit + 1;
+        // we also sort cursor col in same direction. (direction doesn't matter)
+        const orderBy = (0, query_impl_1.reverseOrderBy)(this.options.orderby);
+        if (this.offset) {
+            const keyValuePairs = {};
+            for (const [key, value] of this.cursorKeyValues) {
+                keyValuePairs[key] = value;
             }
+            options.clause = clause.AndOptional(options.clause, clause.PaginationUnboundColsQuery(orderBy.map((orderBy) => ({
+                sortCol: orderBy.column,
+                sortValue: keyValuePairs[orderBy.column],
+                direction: orderBy.direction,
+                nullsPlacement: orderBy.nullsPlacement,
+                overrideAlias: orderBy.alias,
+            }))));
         }
-        options.orderby = orderby;
+        options.orderby = orderBy;
         return options;
     }
     paginationInfo(id) {
@@ -318,7 +229,7 @@ class LastFilter {
     }
 }
 class BaseEdgeQuery {
-    constructor(viewer, sortColOrOptions, cursorColMaybe) {
+    constructor(viewer, options) {
         this.viewer = viewer;
         this.filters = [];
         this.edges = new Map();
@@ -377,57 +288,29 @@ class BaseEdgeQuery {
             await Promise.all(promises);
             return results;
         };
-        let sortCol;
-        let cursorCol;
-        let sortColIsDate = false;
-        let cursorColIsDate = false;
-        if (typeof sortColOrOptions === "string") {
-            sortCol = sortColOrOptions;
-            cursorCol = cursorColMaybe;
-            this.edgeQueryOptions = {
-                cursorCol,
-                orderby: [
-                    {
-                        column: sortCol,
-                        direction: "DESC",
-                    },
-                ],
-            };
-        }
-        else {
-            if (typeof sortColOrOptions.orderby === "string") {
-                sortCol = sortColOrOptions.orderby;
-            }
-            else {
-                // TODO this orderby isn't consistent and this logic needs to be changed anywhere that's using this and this.getSortCol()
-                sortCol = sortColOrOptions.orderby[0].column;
-                sortColIsDate = sortColOrOptions.orderby[0].dateColumn ?? false;
-            }
-            cursorCol = sortColOrOptions.cursorCol;
-            cursorColIsDate = sortColOrOptions.cursorColIsDate ?? false;
-            this.edgeQueryOptions = sortColOrOptions;
-        }
-        this.sortCol = sortCol;
-        this.sortColIsDate = sortColIsDate;
-        this.cursorColIsDate = cursorColIsDate;
-        let m = orderbyRegex.exec(sortCol);
-        if (!m) {
-            throw new Error(`invalid sort column ${sortCol}`);
-        }
-        this.sortCol = m[1];
-        if (m[2]) {
-            throw new Error(`passing direction in sort column is not supproted. use orderby`);
+        // we also sort cursor col in same direction. (direction doesn't matter)
+        const orderBy = [...options.orderby];
+        if (!options.orderby.some((orderBy) => orderBy.column === options.cursorCol)) {
+            orderBy.push({
+                column: options.cursorCol,
+                direction: orderBy?.[0].direction || "DESC",
+            });
         }
-        this.cursorCol = cursorCol;
+        orderBy.forEach((o) => {
+            o.alias =
+                o.alias ??
+                    (options.fieldOptions?.disableFieldsAlias
+                        ? undefined
+                        : (options.fieldOptions?.fieldsAlias ?? options.fieldOptions?.alias));
+        });
+        this.edgeQueryOptions = { ...options, orderby: orderBy };
+        this.cursorCol = options.cursorCol;
+        this.cursorKeys = orderBy.map((orderBy) => orderBy.column);
         this.memoizedloadEdges = (0, memoizee_1.default)(this.loadEdges.bind(this));
         this.genIDInfosToFetch = (0, memoizee_1.default)(this.genIDInfosToFetchImpl.bind(this));
-        this.cursorKeys.push(this.cursorCol);
-        if (this.includeSortColInCursor(this.edgeQueryOptions)) {
-            this.cursorKeys.push(this.sortCol);
-        }
     }
-    getSortCol() {
-        return this.sortCol;
+    getCursorCol() {
+        return this.cursorCol;
     }
     getPrivacyPolicy() {
         // default PrivacyPolicy is always allow. nothing to do here
@@ -439,11 +322,8 @@ class BaseEdgeQuery {
         this.filters.push(new FirstFilter({
             limit: n,
             after,
-            sortCol: this.sortCol,
             cursorCol: this.cursorCol,
             cursorKeys: this.cursorKeys,
-            cursorColIsDate: this.cursorColIsDate,
-            sortColIsDate: this.sortColIsDate,
             orderby: this.edgeQueryOptions.orderby,
             query: this,
             fieldOptions: this.edgeQueryOptions.fieldOptions,
@@ -466,11 +346,8 @@ class BaseEdgeQuery {
         this.filters.push(new LastFilter({
             limit: n,
             before,
-            sortCol: this.sortCol,
             cursorCol: this.cursorCol,
             cursorKeys: this.cursorKeys,
-            cursorColIsDate: this.cursorColIsDate,
-            sortColIsDate: this.sortColIsDate,
             orderby: this.edgeQueryOptions.orderby,
             query: this,
             fieldOptions: this.edgeQueryOptions.fieldOptions,
@@ -583,13 +460,10 @@ class BaseEdgeQuery {
         this.queryDispatched = true;
         return this.edges;
     }
-    includeSortColInCursor(options) {
-        return false;
-    }
     getCursor(row) {
         return (0, ent_1.getCursor)({
             row,
-            keys: this.cursorKeys,
+            cursorKeys: this.cursorKeys,
         });
     }
 }

package/core/query/shared_test.d.ts

@@ -1,10 +1,10 @@
-import { Data, ID, Viewer } from "../base";
-import { FakeUser, FakeContact } from "../../testutils/fake_data/index";
-import { EdgeQuery } from "./query";
 import { BuilderSchema } from "../../testutils/builder";
+import { FakeContact, FakeUser } from "../../testutils/fake_data/index";
 import { MockLogs } from "../../testutils/mock_log";
+import { Data, ID, Viewer } from "../base";
 import { Clause } from "../clause";
 import { OrderBy } from "../query_impl";
+import { EdgeQuery } from "./query";
 interface options<TData extends Data> {
     newQuery: (v: Viewer, user: FakeUser) => EdgeQuery<FakeUser, FakeContact, TData>;
     tableName: string;

package/core/query/shared_test.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonTests = void 0;
-const ent_1 = require("../ent");
-const global_schema_1 = require("../global_schema");
-const viewer_1 = require("../viewer");
+const action_1 = require("../../action");
+const builder_1 = require("../../testutils/builder");
+const test_context_1 = require("../../testutils/context/test_context");
+const temp_db_1 = require("../../testutils/db/temp_db");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
-const temp_db_1 = require("../../testutils/db/temp_db");
-const test_context_1 = require("../../testutils/context/test_context");
-const logger_1 = require("../logger");
+const query_1 = require("../../testutils/query");
 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");
+const ent_1 = require("../ent");
+const global_schema_1 = require("../global_schema");
+const logger_1 = require("../logger");
 const query_impl_1 = require("../query_impl");
-const query_1 = require("../../testutils/query");
+const viewer_1 = require("../viewer");
 const commonTests = (opts) => {
     (0, logger_1.setLogLevels)(["query", "error"]);
     const ml = opts.ml;
@@ -154,7 +154,7 @@ const commonTests = (opts) => {
             let expLimit = disablePaginationBump ? limit : limit + 1;
             expect(whereClause, `${i}`).toBe(
             // default limit
-            `${opts.clause.clause(1)} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(orderby)}, ${uniqCol} ${orderby[0].direction} LIMIT ${expLimit}`);
+            `${opts.clause.clause(1)} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(orderby)} LIMIT ${expLimit}`);
         }
     }
     function verifyCountQuery({ length = 1, numQueries = 1 }) {
@@ -167,40 +167,47 @@ const commonTests = (opts) => {
     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.orderby[0].column, opts.orderby[0].direction === "DESC" ? "<" : ">", opts.tableName, uniqCol, "").clause(opts.clause.values().length + 1);
+        const cmp = (0, clause_1.PaginationUnboundColsQuery)(opts.orderby.map((orderBy) => ({
+            direction: orderBy.direction,
+            sortCol: orderBy.column,
+            sortValue: "_",
+        }))).clause(opts.clause.values().length + 1);
         // order of parts is different in custom query seemingly
         const customQuery = isCustomQuery(filter);
         if (!customQuery && parts[parts.length - 1] === "deleted_at IS NULL") {
             parts = parts
                 .slice(0, parts.length - 1)
-                .concat([cmp, "deleted_at IS NULL"]);
+                .concat([`(${cmp})`, "deleted_at IS NULL"]);
         }
         else {
-            parts.push(cmp);
+            parts.push(`(${cmp})`);
         }
-        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}`);
+        expect((0, query_1.getWhereClause)(ml.logs[0])).toBe(`${parts.join(" AND ")} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(opts.orderby)} LIMIT ${limit + 1}`);
     }
     function verifyLastBeforeCursorQuery(filter, { length = 1, limit = 3, orderby = opts.orderby }) {
         // 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)(orderby[0].column, orderby[0].direction === "ASC" ? ">" : "<", opts.tableName, uniqCol, "").clause(opts.clause.values().length + 1);
+        const cmp = (0, clause_1.PaginationUnboundColsQuery)(opts.orderby.map((orderBy) => ({
+            // Reverse order for "last" cursor
+            direction: orderBy.direction === "DESC" ? "ASC" : "DESC",
+            sortCol: orderBy.column,
+            sortValue: "_",
+        }))).clause(opts.clause.values().length + 1);
         // order of parts is different in custom query seemingly
         const customQuery = isCustomQuery(filter);
         if (!customQuery && parts[parts.length - 1] === "deleted_at IS NULL") {
             parts = parts
                 .slice(0, parts.length - 1)
-                .concat([cmp, "deleted_at IS NULL"]);
+                .concat([`(${cmp})`, "deleted_at IS NULL"]);
         }
         else {
-            parts.push(cmp);
+            parts.push(`(${cmp})`);
         }
         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}`);
+        `${parts.join(" AND ")} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(orderby)} LIMIT ${limit + 1}`);
     }
     function getViewer() {
         return new viewer_1.LoggedOutViewer();
@@ -210,7 +217,8 @@ const commonTests = (opts) => {
         if (isCustomQuery(q)) {
             opts = {
                 row: contacts[idx],
-                keys: ["id"],
+                cursorKeys: ["created_at", "id"],
+                rowKeys: ["createdAt", "id"],
             };
         }
         else {
@@ -218,8 +226,8 @@ const commonTests = (opts) => {
             // is from assoc_edge table id2 field and so cursor takes it from there
             opts = {
                 row: contacts[idx],
-                keys: ["id2"],
-                cursorKeys: ["id"],
+                cursorKeys: ["time", "id2"],
+                rowKeys: ["createdAt", "id"],
             };
         }
         return (0, ent_1.getCursor)(opts);

package/core/query_impl.d.ts

@@ -4,7 +4,6 @@ export interface OrderByOption {
     direction: "ASC" | "DESC";
     alias?: string;
     nullsPlacement?: "first" | "last";
-    dateColumn?: boolean;
 }
 export type OrderBy = OrderByOption[];
 export declare function getOrderByPhrase(orderby: OrderBy, alias?: string): string;

package/graphql/query/edge_connection.d.ts

@@ -1,18 +1,19 @@
-import { EdgeQuery, PaginationInfo } from "../../core/query/query";
 import { Data, Ent, ID, Viewer } from "../../core/base";
+import { EdgeQuery, PaginationInfo } from "../../core/query/query";
 export interface GraphQLEdge<T extends Data> {
     edge: T;
     node: Ent;
     cursor: string;
 }
+type MaybePromise<T> = T | Promise<T>;
 interface edgeQueryCtr<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
-    (v: TViewer, src: T): EdgeQuery<T, Ent, TEdge>;
+    (v: TViewer, src: T): MaybePromise<EdgeQuery<T, Ent, TEdge>>;
 }
 interface edgeQueryCtr2<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
-    (v: TViewer): EdgeQuery<T, Ent, TEdge>;
+    (v: TViewer): MaybePromise<EdgeQuery<T, Ent, TEdge>>;
 }
 export declare class GraphQLEdgeConnection<TSource extends Ent, TEdge extends Data, TViewer extends Viewer = Viewer> {
-    query: EdgeQuery<TSource, Ent, TEdge>;
+    query: Promise<EdgeQuery<TSource, Ent, TEdge>>;
     private results;
     private viewer;
     private source?;

package/graphql/query/edge_connection.js

@@ -7,13 +7,13 @@ class GraphQLEdgeConnection {
         this.results = [];
         this.viewer = viewer;
         if (typeof arg2 === "function") {
-            this.query = arg2(this.viewer);
+            this.query = Promise.resolve(arg2(this.viewer));
         }
         else {
             this.source = arg2;
         }
         if (typeof arg3 === "function") {
-            this.query = arg3(this.viewer, this.source);
+            this.query = Promise.resolve(arg3(this.viewer, this.source));
         }
         else {
             this.args = arg3;
@@ -29,27 +29,31 @@ class GraphQLEdgeConnection {
                 throw new Error("cannot process before without last");
             }
             if (this.args.first) {
-                this.query = this.query.first(this.args.first, this.args.after);
+                const argFirst = this.args.first;
+                const argAfter = this.args.after;
+                this.query = this.query.then((query) => query.first(argFirst, argAfter));
             }
             if (this.args.last) {
-                this.query = this.query.last(this.args.last, this.args.cursor);
+                const argLast = this.args.last;
+                const argBefore = this.args.before;
+                this.query = this.query.then((query) => query.last(argLast, argBefore));
             }
             // TODO custom args
             // how to proceed
         }
     }
     first(limit, cursor) {
-        this.query = this.query.first(limit, cursor);
+        this.query = this.query.then((query) => query.first(limit, cursor));
     }
     last(limit, cursor) {
-        this.query = this.query.last(limit, cursor);
+        this.query = this.query.then((query) => query.last(limit, cursor));
     }
     // any custom filters can be applied here...
     modifyQuery(fn) {
-        this.query = fn(this.query);
+        this.query = this.query.then((query) => fn(query));
     }
     async queryTotalCount() {
-        return this.query.queryRawCount();
+        return (await this.query).queryRawCount();
     }
     async queryEdges() {
         // because of privacy, we need to query the node regardless of if the node is there
@@ -60,7 +64,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 this.query.queryEnts();
+        return (await this.query).queryEnts();
     }
     defaultPageInfo() {
         return {
@@ -72,7 +76,7 @@ class GraphQLEdgeConnection {
     }
     async queryPageInfo() {
         await this.queryData();
-        const paginationInfo = this.query.paginationInfo();
+        const paginationInfo = (await this.query).paginationInfo();
         if (this.source !== undefined) {
             return paginationInfo.get(this.source.id) || this.defaultPageInfo();
         }
@@ -85,24 +89,25 @@ class GraphQLEdgeConnection {
         return this.defaultPageInfo();
     }
     async queryData() {
+        const query = await this.query;
         const [edges, ents] = await Promise.all([
             // TODO need a test that this will only fetch edges once
             // and then fetch ents afterward
-            this.query.queryEdges(),
-            this.query.queryEnts(),
+            query.queryEdges(),
+            query.queryEnts(),
         ]);
         let entsMap = new Map();
         ents.forEach((ent) => entsMap.set(ent.id, ent));
         let results = [];
         for (const edge of edges) {
-            const node = entsMap.get(this.query.dataToID(edge));
+            const node = entsMap.get(query.dataToID(edge));
             if (!node) {
                 continue;
             }
             results.push({
                 edge,
                 node,
-                cursor: this.query.getCursor(edge),
+                cursor: query.getCursor(edge),
             });
         }
         this.results = results;

package/graphql/query/shared_edge_connection.d.ts

@@ -1,6 +1,6 @@
-import { Viewer, Data, Ent } from "../../core/base";
-import { FakeContact } from "../../testutils/fake_data/index";
+import { Data, Ent, Viewer } from "../../core/base";
 import { EdgeQuery } from "../../core/query/query";
+import { FakeContact } from "../../testutils/fake_data/index";
 interface options<TEnt extends Ent, TEdge extends Data> {
     getQuery: (v: Viewer, src: Ent) => EdgeQuery<TEnt, Ent, TEdge>;
     tableName: string;