@snowtop/ent 0.1.12 → 0.1.13

package/core/loaders/assoc_count_loader.js

@@ -65,7 +65,7 @@ class AssocEdgeCountLoader {
             });
         }
         const loader = await this.loaderFn();
-        return await loader.load(id);
+        return loader.load(id);
     }
     clearAll() {
         this.loader && this.loader.clearAll();

package/core/loaders/assoc_edge_loader.d.ts

@@ -2,6 +2,7 @@ import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory } from "..
 import { AssocEdge, AssocEdgeConstructor } from "../ent";
 export interface AssocLoader<T extends AssocEdge> extends Loader<ID, T[]> {
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
+    loadTwoWay(id: ID): Promise<T[]>;
 }
 export declare class AssocEdgeLoader<T extends AssocEdge> implements Loader<ID, T[]> {
     private edgeType;
@@ -13,6 +14,7 @@ export declare class AssocEdgeLoader<T extends AssocEdge> implements Loader<ID,
     constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options: EdgeQueryableDataOptions, context: Context);
     private getLoader;
     load(id: ID): Promise<T[]>;
+    loadTwoWay(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;
 }
@@ -23,6 +25,7 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
+    loadTwoWay(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;
 }

package/core/loaders/assoc_edge_loader.js

@@ -113,6 +113,15 @@ class AssocEdgeLoader {
         const loader = await this.loaderFn();
         return loader.load(id);
     }
+    async loadTwoWay(id) {
+        return (0, ent_1.loadTwoWayEdges)({
+            ctr: this.edgeCtr,
+            id1: id,
+            edgeType: this.edgeType,
+            context: this.context,
+            queryOptions: this.options,
+        });
+    }
     // maybe eventually optimize this
     async loadEdgeForID2(id, id2) {
         return (0, ent_1.loadEdgeForID2)({
@@ -145,6 +154,15 @@ class AssocDirectEdgeLoader {
             ctr: this.edgeCtr,
         });
     }
+    async loadTwoWay(id) {
+        return (0, ent_1.loadTwoWayEdges)({
+            ctr: this.edgeCtr,
+            id1: id,
+            edgeType: this.edgeType,
+            context: this.context,
+            queryOptions: this.options,
+        });
+    }
     async loadEdgeForID2(id, id2) {
         return (0, ent_1.loadEdgeForID2)({
             id1: id,

package/core/loaders/object_loader.js

@@ -67,7 +67,7 @@ async function loadRowsForClauseLoader(options, clause) {
     const rowOptions = {
         ...options,
         // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
-        clause: (0, clause_1.getCombinedClause)(options, clause),
+        clause: (0, clause_1.getCombinedClause)(options, clause, true),
     };
     return (await (0, ent_1.loadRows)(rowOptions));
 }
@@ -75,7 +75,7 @@ async function loadCountForClauseLoader(options, clause) {
     const rowOptions = {
         ...options,
         // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
-        clause: (0, clause_1.getCombinedClause)(options, clause),
+        clause: (0, clause_1.getCombinedClause)(options, clause, true),
     };
     const row = await (0, ent_1.loadRow)({
         ...rowOptions,

package/core/loaders/query_loader.d.ts

@@ -1,14 +1,14 @@
-import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
+import { Context, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
 import { OrderBy } from "../query_impl";
 declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     private options;
     private queryOptions?;
-    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, import("../base").ID | null>> | undefined;
     private memoizedInitPrime;
     private primedLoaders;
-    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, import("../base").ID | null>> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;

package/core/loaders/query_loader.js

@@ -57,9 +57,10 @@ async function simpleCase(options, id, queryOptions) {
         throw new Error(`need options.groupCol or options.clause`);
     }
     if (queryOptions?.clause) {
+        // TODO does this one need a getCombinedClause check??
         cls = clause.And(cls, queryOptions.clause);
     }
-    return await (0, ent_1.loadRows)({
+    return (0, ent_1.loadRows)({
         ...options,
         clause: cls,
         orderby: getOrderByLocal(options, queryOptions),

package/core/loaders/raw_count_loader.js

@@ -113,7 +113,7 @@ class RawCountLoader {
     }
     async load(id) {
         if (this.loader) {
-            return await this.loader.load(id);
+            return this.loader.load(id);
         }
         const rows = await simpleCase(this.options, id, this.context);
         return rows[0];

package/core/query/assoc_query.d.ts

@@ -11,6 +11,7 @@ export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, T
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
+    private loadTwoWay;
     constructor(viewer: TViewer, src: EdgeQuerySource<TSource, TDest, TViewer>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest, TViewer> | loaderOptionsFunc<TViewer>);
     private isEdgeQuery;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
@@ -27,6 +28,27 @@ export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, T
     __beforeBETA(time: Date): this;
     __afterBETA(time: Date): this;
     __withinBeta(start: Date, end: Date): this;
+    /**
+     * intersect multiple queries together with this one to get candidate edges
+     * the edges returned will always be from the originating edge query
+     *
+     * @param others list of other queries to intersect with the source edge
+     */
+    __intersect(...others: AssocEdgeQueryBase<any, TDest, TEdge, TViewer>[]): this;
+    /**
+     * union multiple queries together with this one to get candidate edges
+     * if the edge exists in the source query, that's the edge returned
+     * if the edge doesn't exist, the first edge in the list of queries that has the edge is returned
+     * @param others list of other queries to union with the source edge
+     */
+    __union<TSource2 extends Ent<TViewer>>(...others: AssocEdgeQueryBase<TSource2, TDest, TEdge, TViewer>[]): this;
+    /**
+     * this fetches edges where there's a two way connection between both sets of edges
+     * e.g. in a social networking system, where the source and dest are both following each other
+     *
+     * will not work in the future when there's sharding...
+     */
+    __twoWay(): 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

@@ -39,6 +39,7 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
         this.countLoaderFactory = countLoaderFactory;
         this.dataLoaderFactory = dataLoaderFactory;
         this.options = options;
+        this.loadTwoWay = false;
     }
     isEdgeQuery(obj) {
         if (obj.queryIDs !== undefined) {
@@ -147,7 +148,9 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
             // doesn't make sense
             // so only makes sense if one of these...
             // Id2 needs to be an option
-            const edges = await loader.load(info.id);
+            const edges = this.loadTwoWay
+                ? await loader.loadTwoWay(info.id)
+                : await loader.load(info.id);
             this.edges.set(info.id, edges);
         }));
     }
@@ -186,10 +189,47 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
     }
     // start is inclusive, end is exclusive
     __withinBeta(start, end) {
-        this.__assertNoFiltersBETA("after");
+        this.__assertNoFiltersBETA("within");
         this.__addCustomFilterBETA(new WithinFilter(start, end));
         return this;
     }
+    /**
+     * intersect multiple queries together with this one to get candidate edges
+     * the edges returned will always be from the originating edge query
+     *
+     * @param others list of other queries to intersect with the source edge
+     */
+    __intersect(...others) {
+        // TODO I don't really see a reason why we can't chain first or something first before this
+        // but for now let's not support it
+        // when we do this correctly, we'll allow chaining
+        this.__assertNoFiltersBETA("intersect");
+        this.__addCustomFilterBETA(new IntersectFilter(others));
+        return this;
+    }
+    /**
+     * union multiple queries together with this one to get candidate edges
+     * if the edge exists in the source query, that's the edge returned
+     * if the edge doesn't exist, the first edge in the list of queries that has the edge is returned
+     * @param others list of other queries to union with the source edge
+     */
+    __union(...others) {
+        // same chain comment from intersect...
+        this.__assertNoFiltersBETA("union");
+        this.__addCustomFilterBETA(new UnionFilter(others));
+        return this;
+    }
+    /**
+     * this fetches edges where there's a two way connection between both sets of edges
+     * e.g. in a social networking system, where the source and dest are both following each other
+     *
+     * will not work in the future when there's sharding...
+     */
+    __twoWay() {
+        this.__assertNoFiltersBETA("twoWay");
+        this.loadTwoWay = true;
+        return this;
+    }
 }
 exports.AssocEdgeQueryBase = AssocEdgeQueryBase;
 class BeforeFilter {
@@ -223,3 +263,62 @@ class WithinFilter {
         return options;
     }
 }
+class IntersectFilter {
+    constructor(queries) {
+        this.queries = queries;
+        this.edges = [];
+    }
+    async fetch() {
+        let i = 0;
+        // maybe future optimization. instead of this, use a SQL query if edge_types are the same
+        for await (const query of this.queries) {
+            const edges = await query.queryEdges();
+            const set = new Set();
+            edges.forEach((edge) => {
+                set.add(edge.id2);
+            });
+            this.edges[i] = set;
+            i++;
+        }
+    }
+    filter(_id, edges) {
+        return edges.filter((edge) => {
+            return this.edges.every((set) => {
+                return set.has(edge.id2);
+            });
+        });
+    }
+}
+class UnionFilter {
+    constructor(queries) {
+        this.queries = queries;
+        this.edges = [];
+    }
+    async fetch() {
+        let i = 0;
+        // maybe future optimization. instead of this, use a SQL query if edge_types are the same
+        for await (const query of this.queries) {
+            const edges = await query.queryEdges();
+            this.edges[i] = edges;
+            i++;
+        }
+    }
+    filter(_id, edges) {
+        const set = new Set();
+        const result = [];
+        for (const edge of edges) {
+            set.add(edge.id2);
+            result.push(edge);
+        }
+        for (const edges of this.edges) {
+            for (const edge of edges) {
+                if (set.has(edge.id2)) {
+                    continue;
+                }
+                result.push(edge);
+                set.add(edge.id2);
+            }
+        }
+        return result;
+    }
+}

package/core/query/custom_query.js

@@ -7,17 +7,10 @@ const loaders_1 = require("../loaders");
 const query_1 = require("./query");
 function getClause(opts) {
     let cls = opts.clause;
-    if (opts.disableTransformations) {
+    if (opts.disableTransformations || !cls) {
         return cls;
     }
-    let optClause = opts.loadEntOptions.loaderFactory?.options?.clause;
-    if (typeof optClause === "function") {
-        optClause = optClause();
-    }
-    if (!optClause) {
-        return cls;
-    }
-    return (0, clause_1.AndOptional)(cls, optClause);
+    return (0, clause_1.getCombinedClause)(opts.loadEntOptions.loaderFactory?.options, cls, true);
 }
 function getRawCountLoader(viewer, opts) {
     if (!viewer.context?.cache) {

package/core/query/query.d.ts

@@ -20,6 +20,7 @@ export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends
     sourceEnt(id: ID): Promise<Ent | null>;
 }
 export interface EdgeQueryFilter<T extends Data> {
+    fetch?(): Promise<void>;
     filter?(id: ID, edges: T[]): T[];
     query?(options: EdgeQueryableDataOptions): EdgeQueryableDataOptions | Promise<EdgeQueryableDataOptions>;
     paginationInfo?(id: ID): PaginationInfo | undefined;

package/core/query/query.js

@@ -65,6 +65,7 @@ class FirstFilter {
     constructor(options) {
         this.options = options;
         this.pageMap = new Map();
+        this.usedQuery = false;
         assertPositive(options.limit);
         this.sortCol = options.sortCol;
         if (options.after) {
@@ -72,18 +73,58 @@ class FirstFilter {
         }
         this.edgeQuery = options.query;
     }
+    setPageMap(ret, id, hasNextPage) {
+        this.pageMap.set(id, {
+            hasNextPage,
+            // 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]),
+        });
+    }
     filter(id, edges) {
         if (edges.length > this.options.limit) {
-            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]),
-            });
-            return ret;
+            //  we need a way to know where the cursor is and if we used it and if not need to do this in TypeScript and not in SQL
+            // so can't filter from 0 but specific item
+            // if we used the query or we're querying the first N, slice from 0
+            if (this.usedQuery || !this.offset) {
+                const ret = edges.slice(0, this.options.limit);
+                this.setPageMap(ret, id, true);
+                return ret;
+            }
+            else if (this.offset) {
+                const ret = [];
+                let found = false;
+                let i = 0;
+                let hasNextPage = false;
+                for (const edge of edges) {
+                    const id = edge[this.options.cursorCol];
+                    if (id === this.offset) {
+                        // found!
+                        found = true;
+                        hasNextPage = true;
+                        continue;
+                    }
+                    if (found) {
+                        ret.push(edge);
+                        if (ret.length === this.options.limit) {
+                            if (i === ret.length - 1) {
+                                hasNextPage = false;
+                            }
+                            break;
+                        }
+                    }
+                    i++;
+                }
+                if (hasNextPage && ret.length < this.options.limit) {
+                    hasNextPage = false;
+                }
+                if (ret.length) {
+                    this.setPageMap(ret, id, hasNextPage);
+                }
+                return ret;
+            }
         }
         // TODO: in the future, when we have caching for edges
         // we'll want to hit that cache instead of passing the limit down to the
@@ -93,6 +134,7 @@ class FirstFilter {
         return edges;
     }
     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;
@@ -212,7 +254,7 @@ class BaseEdgeQuery {
         this.limitAdded = false;
         // this is basically just raw rows
         this.queryEdges = async () => {
-            return await this.querySingleEdge("queryEdges");
+            return this.querySingleEdge("queryEdges");
         };
         this.queryAllEdges = async () => {
             return this.memoizedloadEdges();
@@ -402,15 +444,34 @@ class BaseEdgeQuery {
         // may need to bring sql mode or something back
         for (const filter of this.filters) {
             if (filter.query) {
+                if (filter.fetch) {
+                    throw new Error(`a filter that augments the query cannot currently fetch`);
+                }
                 let res = filter.query(options);
                 options = (0, types_1.isPromise)(res) ? await res : res;
             }
+            else {
+                // if we've seen a filter that doesn't have a query, we can't do anything in SQL
+                // TODO figure out filter interactions https://github.com/lolopinto/ent/issues/685
+                // this is a scenario where if we have the first N filters that can modify the query,
+                // we do that in SQL and then we do the rest in code
+                // but once we have something doing it in code (e.g. intersect()), we can't do anything else in SQL
+                // and then have to differentiate between filters that augment (limit or add to) the items returned
+                // and those that reorder...
+                break;
+            }
         }
         await this.loadRawData(idsInfo, options);
         // no filters. nothing to do here.
         if (!this.filters.length) {
             return this.edges;
         }
+        // fetch anything we need to filter the query
+        for await (const filter of this.filters) {
+            if (filter.fetch) {
+                await filter.fetch();
+            }
+        }
         // filter as needed
         for (let [id, edges] of this.edges) {
             this.filters.forEach((filter) => {