@snowtop/ent 0.1.0-alpha90 → 0.1.0-alpha91

package/core/query/query.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -27,6 +31,8 @@ const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const memoizee_1 = __importDefault(require("memoizee"));
 const privacy_1 = require("../privacy");
+const uuid_1 = require("uuid");
+const util_1 = require("util");
 // TODO can we generalize EdgeQuery to support any clause
 function assertPositive(n) {
     if (n < 0) {
@@ -36,31 +42,32 @@ function assertPositive(n) {
 function assertValidCursor(cursor, col) {
     let decoded = Buffer.from(cursor, "base64").toString("ascii");
     let parts = decoded.split(":");
+    // uuid, don't parse int since it tries to validate just first part
+    if ((0, uuid_1.validate)(parts[1])) {
+        return parts[1];
+    }
     // invalid or unknown cursor. nothing to do here.
     if (parts.length !== 2 || parts[0] !== col) {
         throw new Error(`invalid cursor ${cursor} passed`);
     }
-    // TODO check if numeric or not but for now we're only doing numbers
+    // TODO handle both cases... (time vs not) better
+    // TODO change this to only do the parseInt part if time...
+    // pass flag indicating if time?
     const time = parseInt(parts[1], 10);
     if (isNaN(time)) {
-        throw new Error(`invalid cursor ${cursor} passed`);
+        return parts[1];
     }
     return time;
 }
+const orderbyRegex = new RegExp(/([0-9a-z_]+)[ ]?([0-9a-z_]+)?/i);
 class FirstFilter {
     constructor(options) {
         this.options = options;
         this.pageMap = new Map();
         assertPositive(options.limit);
-        if (options.before) {
-            throw new Error(`cannot specify before with a first filter`);
-        }
-        this.sortCol = options.sortCol || "time";
+        this.sortCol = options.sortCol;
         if (options.after) {
-            this.offset = assertValidCursor(options.after, this.sortCol);
-        }
-        if (this.options.sortColNotTime && !this.options.sortCol) {
-            throw new Error(`cannot specify sortColNotTime without specifying a sortCol`);
+            this.offset = assertValidCursor(options.after, options.cursorCol);
         }
         this.edgeQuery = options.query;
     }
@@ -69,6 +76,8 @@ class FirstFilter {
             const ret = edges.slice(0, this.options.limit);
             this.pageMap.set(id, {
                 hasNextPage: true,
+                // hasPreviousPage always false even if there's a previous page because
+                // we shouldn't be querying in both directions at the same
                 hasPreviousPage: false,
                 startCursor: this.edgeQuery.getCursor(ret[0]),
                 endCursor: this.edgeQuery.getCursor(ret[ret.length - 1]),
@@ -82,31 +91,34 @@ class FirstFilter {
         // so we'd need a way to indicate whether this is done in sql or not
         return edges;
     }
-    query(options) {
+    async query(options) {
         // we fetch an extra one to see if we're at the end
         const limit = this.options.limit + 1;
         options.limit = limit;
-        // todo may not be desc
-        // and if asc
-        // clause below should switch to greater...
-        const sortCol = this.sortCol.toLowerCase();
-        if (sortCol.endsWith("desc") || sortCol.endsWith("asc")) {
-            options.orderby = `${this.sortCol}`;
-        }
-        else {
-            options.orderby = `${this.sortCol} DESC`;
-        }
+        let orderby = this.options.defaultDirection || "DESC";
         // we sort by most recent first
         // so when paging, we fetch afterCursor X
-        if (this.offset) {
-            if (this.options.sortColNotTime) {
-                options.clause = clause.Less(this.sortCol, this.offset);
+        const less = orderby === "DESC";
+        if (this.options.cursorCol !== this.sortCol) {
+            // we also sort unique col in same direction since it doesn't matter...
+            options.orderby = `${this.sortCol} ${orderby}, ${this.options.cursorCol} ${orderby}`;
+            if (this.offset) {
+                const res = this.edgeQuery.getTableName();
+                const tableName = util_1.types.isPromise(res) ? await res : res;
+                // inner col time
+                options.clause = clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.offset);
             }
-            else {
-                options.clause = clause.Less(this.sortCol, new Date(this.offset).toISOString());
+        }
+        else {
+            options.orderby = `${this.sortCol} ${orderby}`;
+            if (this.offset) {
+                let clauseFn = less ? clause.Less : clause.Greater;
+                let val = this.options.sortColTime
+                    ? new Date(this.offset).toISOString()
+                    : this.offset;
+                options.clause = clauseFn(this.sortCol, val);
             }
         }
-        // console.debug("filter opts", options, this.options);
         return options;
     }
     // TODO?
@@ -119,15 +131,9 @@ class LastFilter {
         this.options = options;
         this.pageMap = new Map();
         assertPositive(options.limit);
-        if (options.after) {
-            throw new Error(`cannot specify after with a last filter`);
-        }
-        this.sortCol = options.sortCol || "time";
+        this.sortCol = options.sortCol;
         if (options.before) {
-            this.offset = assertValidCursor(options.before, this.sortCol);
-        }
-        if (this.options.sortColNotTime && !this.options.sortCol) {
-            throw new Error(`cannot specify sortColNotTime without specifying a sortCol`);
+            this.offset = assertValidCursor(options.before, options.cursorCol);
         }
         this.edgeQuery = options.query;
     }
@@ -144,11 +150,13 @@ class LastFilter {
             }
         }
         else {
-            ret = edges.slice(edges.length - this.options.limit, edges.length);
+            ret = edges.slice(0, this.options.limit);
         }
         if (edges.length > this.options.limit) {
             this.pageMap.set(id, {
                 hasPreviousPage: true,
+                // hasNextPage always false even if there's a next page because
+                // we shouldn't be querying in both directions at the same
                 hasNextPage: false,
                 startCursor: this.edgeQuery.getCursor(ret[0]),
                 endCursor: this.edgeQuery.getCursor(ret[ret.length - 1]),
@@ -156,17 +164,39 @@ class LastFilter {
         }
         return ret;
     }
-    query(options) {
-        if (!this.offset) {
-            return options;
+    async query(options) {
+        // assume desc by default
+        // so last is reverse
+        let orderby = "ASC";
+        if (this.options.defaultDirection) {
+            // reverse sort col shown...
+            if (this.options.defaultDirection === "DESC") {
+                orderby = "ASC";
+            }
+            else {
+                orderby = "DESC";
+            }
         }
-        options.orderby = `${this.sortCol} ASC`;
+        const greater = orderby === "ASC";
         options.limit = this.options.limit + 1; // fetch an extra so we know if previous pag
-        if (this.options.sortColNotTime) {
-            options.clause = clause.Greater(this.sortCol, this.offset);
+        if (this.options.cursorCol !== this.sortCol) {
+            const res = this.edgeQuery.getTableName();
+            const tableName = util_1.types.isPromise(res) ? await res : res;
+            if (this.offset) {
+                // inner col time
+                options.clause = clause.PaginationMultipleColsSubQuery(this.sortCol, greater ? ">" : "<", tableName, this.options.cursorCol, this.offset);
+            }
+            options.orderby = `${this.sortCol} ${orderby}, ${this.options.cursorCol} ${orderby}`;
         }
         else {
-            options.clause = clause.Greater(this.sortCol, new Date(this.offset).toISOString());
+            options.orderby = `${this.sortCol} ${orderby}`;
+            if (this.offset) {
+                let clauseFn = greater ? clause.Greater : clause.Less;
+                let val = this.options.sortColTime
+                    ? new Date(this.offset).toISOString()
+                    : this.offset;
+                options.clause = clauseFn(this.sortCol, val);
+            }
         }
         return options;
     }
@@ -175,9 +205,8 @@ class LastFilter {
     }
 }
 class BaseEdgeQuery {
-    constructor(viewer, sortCol) {
+    constructor(viewer, sortCol, cursorCol) {
         this.viewer = viewer;
-        this.sortCol = sortCol;
         this.filters = [];
         this.edges = new Map();
         this.pagination = new Map();
@@ -233,9 +262,26 @@ class BaseEdgeQuery {
             await Promise.all(promises);
             return results;
         };
+        let m = orderbyRegex.exec(sortCol);
+        if (!m) {
+            throw new Error(`invalid sort column ${sortCol}`);
+        }
+        this.sortCol = m[1];
+        if (m[2]) {
+            // @ts-ignore
+            this.defaultDirection = m[2].toUpperCase();
+        }
+        let m2 = orderbyRegex.exec(cursorCol);
+        if (!m2) {
+            throw new Error(`invalid sort column ${cursorCol}`);
+        }
+        this.cursorCol = m2[1];
         this.memoizedloadEdges = (0, memoizee_1.default)(this.loadEdges.bind(this));
         this.genIDInfosToFetch = (0, memoizee_1.default)(this.genIDInfosToFetchImpl.bind(this));
     }
+    getSortCol() {
+        return this.sortCol;
+    }
     getPrivacyPolicy() {
         // default PrivacyPolicy is always allow. nothing to do here
         return privacy_1.AlwaysAllowPrivacyPolicy;
@@ -246,6 +292,8 @@ class BaseEdgeQuery {
             limit: n,
             after,
             sortCol: this.sortCol,
+            cursorCol: this.cursorCol,
+            defaultDirection: this.defaultDirection,
             query: this,
         }));
         return this;
@@ -256,6 +304,8 @@ class BaseEdgeQuery {
             limit: n,
             before,
             sortCol: this.sortCol,
+            cursorCol: this.cursorCol,
+            defaultDirection: this.defaultDirection,
             query: this,
         }));
         return this;
@@ -307,11 +357,12 @@ class BaseEdgeQuery {
         // TODO once we add a lot of complex filters, this needs to be more complicated
         // e.g. commutative filters. what can be done in sql or combined together etc
         // may need to bring sql mode or something back
-        this.filters.forEach((filter) => {
+        for (const filter of this.filters) {
             if (filter.query) {
-                options = filter.query(options);
+                let res = filter.query(options);
+                options = util_1.types.isPromise(res) ? await res : res;
             }
-        });
+        }
         await this.loadRawData(idsInfo, options);
         // no filters. nothing to do here.
         if (!this.filters.length) {
@@ -338,17 +389,7 @@ class BaseEdgeQuery {
     getCursor(row) {
         return (0, ent_1.getCursor)({
             row,
-            col: this.sortCol,
-            conv: (datum) => {
-                if (datum instanceof Date) {
-                    return datum.getTime();
-                }
-                // sqlite stores it as string and doesn't convert back
-                if (typeof datum === "string") {
-                    return Date.parse(datum);
-                }
-                return datum;
-            },
+            col: this.cursorCol,
         });
     }
 }

package/core/query/shared_assoc_test.d.ts

@@ -1 +1,2 @@
-export declare function assocTests(global?: boolean): void;
+import { MockLogs } from "../../testutils/mock_log";
+export declare function assocTests(ml: MockLogs, global?: boolean): void;

package/core/query/shared_assoc_test.js

@@ -1,33 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assocTests = void 0;
-const db_mock_1 = require("../../testutils/db_mock");
 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 db_1 = __importStar(require("../db"));
-function assocTests(global = false) {
+const clause_1 = require("../clause");
+function assocTests(ml, global = false) {
+    ml.mock();
     describe("custom edge", () => {
         let user1, user2;
         beforeEach(async () => {
@@ -67,40 +48,36 @@ function assocTests(global = false) {
     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 = ent_1.DefaultLimit, disablePaginationBump = false, }) {
-        if (db_1.default.getDialect() === db_1.Dialect.SQLite) {
-            return;
-        }
-        const queries = db_mock_1.QueryRecorder.getCurrentQueries();
-        expect(queries.length).toBe(length);
+        expect(ml.logs.length).toBe(length);
         for (let i = 0; i < numQueries; i++) {
-            const query = queries[i];
+            const whereClause = getWhereClause(ml.logs[i]);
             let expLimit = disablePaginationBump ? limit : limit + 1;
             if (global) {
-                expect(query.qs?.whereClause, `${i}`).toBe(
+                expect(whereClause, `${i}`).toBe(
                 // default limit
-                `id1 = $1 AND edge_type = $2 AND deleted_at IS NULL ORDER BY time DESC LIMIT ${expLimit}`);
+                `${(0, clause_1.And)((0, clause_1.Eq)("id1", ""), (0, clause_1.Eq)("edge_type", ""), (0, clause_1.Eq)("deleted_at", null)).clause(1)} ORDER BY time DESC, id2 DESC LIMIT ${expLimit}`);
             }
             else {
-                expect(query.qs?.whereClause, `${i}`).toBe(
+                expect(whereClause, `${i}`).toBe(
                 // default limit
-                `id1 = $1 AND edge_type = $2 ORDER BY time DESC LIMIT ${expLimit}`);
+                `${(0, clause_1.And)((0, clause_1.Eq)("id1", ""), (0, clause_1.Eq)("edge_type", "")).clause(1)} ORDER BY time DESC, id2 DESC LIMIT ${expLimit}`);
             }
         }
     }
     function verifyCountQuery({ length = 1, numQueries = 1 }) {
-        if (db_1.default.getDialect() === db_1.Dialect.SQLite) {
-            return;
-        }
-        const queries = db_mock_1.QueryRecorder.getCurrentQueries();
-        expect(queries.length).toBe(length);
+        expect(ml.logs.length).toBe(length);
         for (let i = 0; i < numQueries; i++) {
-            const query = queries[i];
+            const whereClause = getWhereClause(ml.logs[i]);
             if (global) {
-                expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2 AND deleted_at IS NULL`);
+                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(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2`);
+                expect(whereClause).toBe(`${(0, clause_1.And)((0, clause_1.Eq)("id1", ""), (0, clause_1.Eq)("edge_type", "")).clause(1)}`);
             }
         }
     }
@@ -115,16 +92,18 @@ function assocTests(global = false) {
         }
         async beforeEach() {
             let [user1, user2, user3] = await Promise.all([
-                (0, test_helpers_1.createAllContacts)({ firstName: "Jon", lastName: "Snow" }),
-                (0, test_helpers_1.createAllContacts)({ firstName: "Aegon", lastName: "Targaryen" }),
-                (0, test_helpers_1.createAllContacts)({ firstName: "Ned", lastName: "Stark" }),
+                (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];
-            db_mock_1.QueryRecorder.clearQueries();
+            ml.clear();
         }
         getQuery(viewer) {
             return this.filter(index_1.UserToContactsQuery.query(viewer || new viewer_1.LoggedOutViewer(), this.dataz.map((data) => data[0])));
@@ -469,7 +448,7 @@ function assocTests(global = false) {
             }
             //order is users, then events
             this.expCount = this.ents([...this.users, ...this.events]).length;
-            db_mock_1.QueryRecorder.clearQueries();
+            ml.clear();
         }
         getQuery(viewer) {
             return this.filter(index_1.UserToFollowingQuery.query(viewer || new viewer_1.IDViewer(this.user.id), this.user));

package/core/query/shared_test.d.ts

@@ -1,16 +1,20 @@
 import { Data, Viewer } from "../base";
 import { FakeUser, FakeContact } from "../../testutils/fake_data/index";
 import { EdgeQuery } from "./query";
+import { MockLogs } from "../../testutils/mock_log";
+import { Clause } from "../clause";
 interface options<TData extends Data> {
     newQuery: (v: Viewer, user: FakeUser) => EdgeQuery<FakeUser, FakeContact, TData>;
     tableName: string;
     uniqKey: string;
+    ml: MockLogs;
     entsLength?: number;
-    where: string;
+    clause: Clause;
     sortCol: string;
     livePostgresDB?: boolean;
     sqlite?: boolean;
     globalSchema?: boolean;
+    orderby: "DESC" | "ASC";
     rawDataVerify?(user: FakeUser): Promise<void>;
 }
 export declare const commonTests: <TData extends Data>(opts: options<TData>) => void;