@snowtop/ent 0.1.0 → 0.1.2

package/action/operations.js

@@ -390,7 +390,8 @@ class EdgeOperation {
             // maybe when actions exist?
             fields["time"] = new Date().toISOString();
         }
-        const onConflictFields = ["data"];
+        // update time if we're trying to insert a row with the same id1, edge_type, id2
+        const onConflictFields = ["data", "time"];
         const extraEdgeFields = (0, global_schema_1.__getGlobalSchema)()?.extraEdgeFields;
         if (extraEdgeFields) {
             for (const name in extraEdgeFields) {

package/core/query/assoc_query.d.ts

@@ -24,6 +24,9 @@ export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, T
     protected loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     queryID2(id2: ID): Promise<TEdge | undefined>;
     queryAllID2(id2: ID): Promise<Map<ID, TEdge>>;
+    __beforeBETA(time: Date): this;
+    __afterBETA(time: Date): this;
+    __withinBeta(start: Date, end: Date): this;
 }
 export interface EdgeQueryCtr<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> {
     new (viewer: Viewer, src: EdgeQuerySource<TSource>): EdgeQuery<TSource, TDest, TEdge>;

package/core/query/assoc_query.js

@@ -1,8 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+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.AssocEdgeQueryBase = void 0;
 const ent_1 = require("../ent");
 const query_1 = require("./query");
+const clause = __importStar(require("../clause"));
 // would be nice to someday have an API for assoc asc
 class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
     constructor(viewer, src, countLoaderFactory, dataLoaderFactory, 
@@ -150,5 +174,52 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
         }));
         return m;
     }
+    __beforeBETA(time) {
+        this.__assertNoFiltersBETA("before");
+        this.__addCustomFilterBETA(new BeforeFilter(time));
+        return this;
+    }
+    __afterBETA(time) {
+        this.__assertNoFiltersBETA("after");
+        this.__addCustomFilterBETA(new AfterFilter(time));
+        return this;
+    }
+    // start is inclusive, end is exclusive
+    __withinBeta(start, end) {
+        this.__assertNoFiltersBETA("after");
+        this.__addCustomFilterBETA(new WithinFilter(start, end));
+        return this;
+    }
 }
 exports.AssocEdgeQueryBase = AssocEdgeQueryBase;
+class BeforeFilter {
+    constructor(time) {
+        this.time = time;
+    }
+    query(options) {
+        const cls = clause.Less("time", this.time);
+        options.clause = clause.AndOptional(options.clause, cls);
+        return options;
+    }
+}
+class AfterFilter {
+    constructor(time) {
+        this.time = time;
+    }
+    query(options) {
+        const cls = clause.Greater("time", this.time);
+        options.clause = clause.AndOptional(options.clause, cls);
+        return options;
+    }
+}
+class WithinFilter {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    query(options) {
+        const cls = clause.And(clause.GreaterEq("time", this.start), clause.Less("time", this.end));
+        options.clause = clause.AndOptional(options.clause, cls);
+        return options;
+    }
+}

package/core/query/query.d.ts

@@ -47,12 +47,15 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private sortCol;
     private cursorCol;
     private edgeQueryOptions;
+    private limitAdded;
     constructor(viewer: Viewer, sortCol: string, cursorCol: string);
     constructor(viewer: Viewer, options: EdgeQueryOptions);
     protected getSortCol(): string;
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
+    __addCustomFilterBETA(filter: EdgeQueryFilter<TEdge>): void;
+    protected __assertNoFiltersBETA(name: string): void;
     last(n: number, before?: string): this;
     private querySingleEdge;
     readonly queryEdges: () => Promise<TEdge[]>;

package/core/query/query.js

@@ -110,7 +110,7 @@ class FirstFilter {
                 const res = this.edgeQuery.getTableName();
                 const tableName = (0, types_1.isPromise)(res) ? await res : res;
                 // inner col time
-                options.clause = clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.offset);
+                options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.offset));
             }
         }
         else {
@@ -119,7 +119,7 @@ class FirstFilter {
                 let val = this.options.sortColTime
                     ? new Date(this.offset).toISOString()
                     : this.offset;
-                options.clause = clauseFn(this.sortCol, val);
+                options.clause = clause.AndOptional(options.clause, clauseFn(this.sortCol, val));
             }
         }
         options.orderby = orderby;
@@ -177,7 +177,7 @@ class LastFilter {
             const tableName = (0, types_1.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.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, greater ? ">" : "<", tableName, this.options.cursorCol, this.offset));
             }
             // we also sort cursor col in same direction. (direction doesn't matter)
             orderby.push({
@@ -191,7 +191,7 @@ class LastFilter {
                 let val = this.options.sortColTime
                     ? new Date(this.offset).toISOString()
                     : this.offset;
-                options.clause = clauseFn(this.sortCol, val);
+                options.clause = clause.AndOptional(options.clause, clauseFn(this.sortCol, val));
             }
         }
         options.orderby = orderby;
@@ -209,6 +209,7 @@ class BaseEdgeQuery {
         this.pagination = new Map();
         this.idMap = new Map();
         this.idsToFetch = [];
+        this.limitAdded = false;
         // this is basically just raw rows
         this.queryEdges = async () => {
             return await this.querySingleEdge("queryEdges");
@@ -306,6 +307,7 @@ class BaseEdgeQuery {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
     first(n, after) {
+        this.limitAdded = true;
         this.assertQueryNotDispatched("first");
         this.filters.push(new FirstFilter({
             limit: n,
@@ -317,7 +319,18 @@ class BaseEdgeQuery {
         }));
         return this;
     }
+    // API subject to change
+    // TODO https://github.com/lolopinto/ent/issues/685
+    __addCustomFilterBETA(filter) {
+        this.filters.push(filter);
+    }
+    __assertNoFiltersBETA(name) {
+        if (this.filters.length !== 0) {
+            throw new Error(`${name} must be the first filter called`);
+        }
+    }
     last(n, before) {
+        this.limitAdded = true;
         this.assertQueryNotDispatched("last");
         this.filters.push(new LastFilter({
             limit: n,
@@ -378,8 +391,9 @@ class BaseEdgeQuery {
     }
     async loadEdges() {
         const idsInfo = await this.genIDInfosToFetch();
-        if (!this.filters.length) {
-            // if no filter, we add the firstN filter to ensure we get pagination info
+        // we need first even if other filters are included...
+        if (!this.limitAdded) {
+            // if no limit filter, we add the firstN filter to ensure we get pagination info
             this.first((0, ent_1.getDefaultLimit)());
         }
         let options = this._defaultEdgeQueryableOptions ?? {};

package/core/query/shared_assoc_test.js

@@ -11,6 +11,7 @@ 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", () => {
@@ -56,21 +57,21 @@ function assocTests(ml, global = false) {
         let execArray = /^SELECT (.+) FROM (.+) WHERE (.+)?/.exec(query.query);
         return execArray?.[3];
     }
-    function verifyQuery({ length = 1, numQueries = 1, limit = (0, ent_1.getDefaultLimit)(), disablePaginationBump = false, }) {
+    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 = 0; i < numQueries; i++) {
+        for (let i = logsStart; i < numQueries; i++) {
             const whereClause = getWhereClause(ml.logs[i]);
             let expLimit = disablePaginationBump ? limit : limit + 1;
-            if (global) {
-                expect(whereClause, `${i}`).toBe(
-                // default limit
-                `${(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(whereClause, `${i}`).toBe(
-                // default limit
-                `${(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}`);
-            }
+            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 }) {
@@ -663,6 +664,290 @@ function assocTests(ml, global = false) {
             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;
     }

package/core/query/shared_test.js

@@ -697,11 +697,11 @@ const commonTests = (opts) => {
             user = u;
             const [_, contacts2] = await (0, test_helpers_1.createAllContacts)({
                 user,
-                start: contacts[contacts.length - 1].createdAt.getTime() - 100,
+                start: contacts[contacts.length - 1].createdAt.getTime() - 86400,
             });
             await (0, test_helpers_1.createAllContacts)({
                 user,
-                start: contacts2[contacts.length - 1].createdAt.getTime() - 100,
+                start: contacts2[contacts.length - 1].createdAt.getTime() - 86400,
             });
             const edges = await opts.newQuery(getViewer(), user).queryEdges();
             // confirm there are duplicates...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/testutils/fake_data/test_helpers.js

@@ -102,7 +102,8 @@ async function createAllContacts(opts) {
     let userInputs = exports.inputs.slice(0, slice || exports.inputs.length);
     const contacts = await Promise.all(userInputs.map(async (input) => {
         // just to make times deterministic so that tests can consistently work
-        (0, jest_date_mock_1.advanceBy)(100);
+        // doing a day so we can do time range queries more easily
+        (0, jest_date_mock_1.advanceBy)(86400);
         const builder = (0, _1.getContactBuilder)(userr.viewer, getContactInput(userr, input));
         // add edge from user to contact
         builder.orchestrator.addInboundEdge(userr.id, _1.EdgeType.UserToContacts, const_1.NodeType.FakeUser, {