@snowtop/ent 0.0.2 → 0.0.3-4.alpha

package/core/privacy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
+exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
 const base_1 = require("./base");
 const ent_1 = require("./ent");
 const logger_1 = require("./logger");
@@ -40,44 +40,44 @@ class EntInvalidPrivacyPolicyError extends Error {
 }
 exports.AlwaysAllowRule = {
     async apply(_v, _ent) {
-        return base_1.Allow();
+        return (0, base_1.Allow)();
     },
 };
 exports.AlwaysDenyRule = {
     async apply(_v, _ent) {
-        return base_1.Deny();
+        return (0, base_1.Deny)();
     },
 };
 exports.DenyIfLoggedOutRule = {
     async apply(v, _ent) {
         if (v.viewerID === null || v.viewerID == undefined) {
-            return base_1.Deny();
+            return (0, base_1.Deny)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     },
 };
 exports.DenyIfLoggedInRule = {
     async apply(v, _ent) {
         if (v.viewerID === null || v.viewerID == undefined) {
-            return base_1.Skip();
+            return (0, base_1.Skip)();
         }
-        return base_1.Deny();
+        return (0, base_1.Deny)();
     },
 };
 exports.AllowIfHasIdentity = {
     async apply(v, _ent) {
         if (v.viewerID === null || v.viewerID == undefined) {
-            return base_1.Skip();
+            return (0, base_1.Skip)();
         }
-        return base_1.Allow();
+        return (0, base_1.Allow)();
     },
 };
 exports.AllowIfViewerRule = {
     async apply(v, ent) {
         if (v.viewerID && v.viewerID === ent?.id) {
-            return base_1.Allow();
+            return (0, base_1.Allow)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     },
 };
 class AllowIfViewerEqualsRule {
@@ -85,7 +85,7 @@ class AllowIfViewerEqualsRule {
         this.id = id;
     }
     async apply(v, _ent) {
-        return v.viewerID === this.id ? base_1.Allow() : base_1.Skip();
+        return v.viewerID === this.id ? (0, base_1.Allow)() : (0, base_1.Skip)();
     }
 }
 exports.AllowIfViewerEqualsRule = AllowIfViewerEqualsRule;
@@ -94,7 +94,7 @@ class DenyIfViewerEqualsRule {
         this.id = id;
     }
     async apply(v, _ent) {
-        return v.viewerID === this.id ? base_1.Deny() : base_1.Skip();
+        return v.viewerID === this.id ? (0, base_1.Deny)() : (0, base_1.Skip)();
     }
 }
 exports.DenyIfViewerEqualsRule = DenyIfViewerEqualsRule;
@@ -105,9 +105,9 @@ class AllowIfFuncRule {
     async apply(v, ent) {
         const result = await this.fn(v, ent);
         if (result) {
-            return base_1.Allow();
+            return (0, base_1.Allow)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.AllowIfFuncRule = AllowIfFuncRule;
@@ -118,12 +118,15 @@ class DenyIfFuncRule {
     async apply(v, ent) {
         const result = await this.fn(v, ent);
         if (result) {
-            return base_1.Deny();
+            return (0, base_1.Deny)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.DenyIfFuncRule = DenyIfFuncRule;
+/**
+ * @deprecated use AllowIfViewerIsEntPropertyRule
+ */
 class AllowIfViewerIsRule {
     constructor(property) {
         this.property = property;
@@ -134,23 +137,64 @@ class AllowIfViewerIsRule {
             result = ent[this.property];
         }
         if (result === v.viewerID) {
-            return base_1.Allow();
+            return (0, base_1.Allow)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.AllowIfViewerIsRule = AllowIfViewerIsRule;
+class AllowIfViewerIsEntPropertyRule {
+    constructor(property) {
+        this.property = property;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        if (result === v.viewerID) {
+            return (0, base_1.Allow)();
+        }
+        return (0, base_1.Skip)();
+    }
+}
+exports.AllowIfViewerIsEntPropertyRule = AllowIfViewerIsEntPropertyRule;
+class AllowIfEntPropertyIsRule {
+    constructor(property, val) {
+        this.property = property;
+        this.val = val;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        if (result === this.val) {
+            return (0, base_1.Allow)();
+        }
+        return (0, base_1.Skip)();
+    }
+}
+exports.AllowIfEntPropertyIsRule = AllowIfEntPropertyIsRule;
+class DenyIfEntPropertyIsRule {
+    constructor(property, val) {
+        this.property = property;
+        this.val = val;
+    }
+    async apply(v, ent) {
+        const result = ent && ent[this.property];
+        if (result === this.val) {
+            return (0, base_1.Deny)();
+        }
+        return (0, base_1.Skip)();
+    }
+}
+exports.DenyIfEntPropertyIsRule = DenyIfEntPropertyIsRule;
 class AllowIfEntIsVisibleRule {
     constructor(id, options) {
         this.id = id;
         this.options = options;
     }
     async apply(v, _ent) {
-        const visible = await ent_1.loadEnt(v, this.id, this.options);
+        const visible = await (0, ent_1.loadEnt)(v, this.id, this.options);
         if (visible === null) {
-            return base_1.Skip();
+            return (0, base_1.Skip)();
         }
-        return base_1.Allow();
+        return (0, base_1.Allow)();
     }
 }
 exports.AllowIfEntIsVisibleRule = AllowIfEntIsVisibleRule;
@@ -160,11 +204,11 @@ class AllowIfEntIsNotVisibleRule {
         this.options = options;
     }
     async apply(v, _ent) {
-        const visible = await ent_1.loadEnt(v, this.id, this.options);
+        const visible = await (0, ent_1.loadEnt)(v, this.id, this.options);
         if (visible === null) {
-            return base_1.Allow();
+            return (0, base_1.Allow)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.AllowIfEntIsNotVisibleRule = AllowIfEntIsNotVisibleRule;
@@ -190,11 +234,11 @@ class DenyIfEntIsVisibleRule {
         this.options = options;
     }
     async apply(v, _ent) {
-        const visible = await ent_1.loadEnt(v, this.id, this.options);
+        const visible = await (0, ent_1.loadEnt)(v, this.id, this.options);
         if (visible === null) {
-            return base_1.Skip();
+            return (0, base_1.Skip)();
         }
-        return base_1.Deny();
+        return (0, base_1.Deny)();
     }
 }
 exports.DenyIfEntIsVisibleRule = DenyIfEntIsVisibleRule;
@@ -204,17 +248,17 @@ class DenyIfEntIsNotVisibleRule {
         this.options = options;
     }
     async apply(v, _ent) {
-        const visible = await ent_1.loadEnt(v, this.id, this.options);
+        const visible = await (0, ent_1.loadEnt)(v, this.id, this.options);
         if (visible === null) {
-            return base_1.Deny();
+            return (0, base_1.Deny)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.DenyIfEntIsNotVisibleRule = DenyIfEntIsNotVisibleRule;
 async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
     if (id1 && id2) {
-        const edge = await ent_1.loadEdgeForID2({
+        const edge = await (0, ent_1.loadEdgeForID2)({
             id1,
             edgeType,
             id2,
@@ -222,10 +266,10 @@ async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
             ctr: ent_1.AssocEdge,
         });
         if (edge) {
-            return base_1.Allow();
+            return (0, base_1.Allow)();
         }
     }
-    return base_1.Skip();
+    return (0, base_1.Skip)();
 }
 class AllowIfEdgeExistsRule {
     constructor(id1, id2, edgeType) {
@@ -259,7 +303,7 @@ exports.AllowIfViewerOutboundEdgeExistsRule = AllowIfViewerOutboundEdgeExistsRul
 async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
     // edge doesn't exist if no viewer
     if (id1 && id2) {
-        const edge = await ent_1.loadEdgeForID2({
+        const edge = await (0, ent_1.loadEdgeForID2)({
             id1,
             edgeType,
             id2,
@@ -267,17 +311,17 @@ async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
             ctr: ent_1.AssocEdge,
         });
         if (edge) {
-            return base_1.Deny();
+            return (0, base_1.Deny)();
         }
     }
-    return base_1.Skip();
+    return (0, base_1.Skip)();
 }
 async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
     // edge doesn't exist if no viewer
     if (!id1 || !id2) {
-        return base_1.Deny();
+        return (0, base_1.Deny)();
     }
-    const edge = await ent_1.loadEdgeForID2({
+    const edge = await (0, ent_1.loadEdgeForID2)({
         id1,
         edgeType,
         id2,
@@ -285,9 +329,9 @@ async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
         ctr: ent_1.AssocEdge,
     });
     if (!edge) {
-        return base_1.Deny();
+        return (0, base_1.Deny)();
     }
-    return base_1.Skip();
+    return (0, base_1.Skip)();
 }
 class DenyIfEdgeExistsRule {
     constructor(id1, id2, edgeType) {
@@ -356,10 +400,10 @@ class AllowIfConditionAppliesRule {
     async apply(v, ent) {
         const result = await this.fn(v, ent);
         if (!result) {
-            return base_1.Skip();
+            return (0, base_1.Skip)();
         }
         const r = await this.rule.apply(v, ent);
-        return r.result === privacyResult.Allow ? base_1.Allow() : base_1.Skip();
+        return r.result === privacyResult.Allow ? (0, base_1.Allow)() : (0, base_1.Skip)();
     }
 }
 exports.AllowIfConditionAppliesRule = AllowIfConditionAppliesRule;
@@ -371,7 +415,7 @@ class DelayedResultRule {
     async apply(v, ent) {
         const rule = await this.fn(v, ent);
         if (!rule) {
-            return base_1.Skip();
+            return (0, base_1.Skip)();
         }
         const res = await rule.apply(v, ent);
         return res;
@@ -386,9 +430,9 @@ class AllowIfSubPolicyAllowsRule {
     async apply(v, ent) {
         const result = await applyPrivacyPolicy(v, this.policy, ent);
         if (result) {
-            return base_1.Allow();
+            return (0, base_1.Allow)();
         }
-        return base_1.Skip();
+        return (0, base_1.Skip)();
     }
 }
 exports.AllowIfSubPolicyAllowsRule = AllowIfSubPolicyAllowsRule;
@@ -400,7 +444,7 @@ async function applyPrivacyPolicy(v, policy, ent) {
         // TODO privacy errors should not throw
         // but other expected errors should throw...
         // we shouldn't just hide them
-        logger_1.log("debug", e);
+        (0, logger_1.log)("debug", e);
         return false;
     }
 }

package/core/query/assoc_query.d.ts

@@ -2,29 +2,29 @@ import { ID, Ent, Viewer, LoadEntOptions, EdgeQueryableDataOptions } from "../ba
 import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
-import { EdgeQuery, BaseEdgeQuery } from "./query";
-export declare type EdgeQuerySource<T extends Ent> = T | T[] | ID | ID[] | EdgeQuery<T, AssocEdge>;
-export declare class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TDest, TEdge> {
+import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
+export declare type EdgeQuerySource<TSource extends Ent, TDest extends Ent = Ent> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
+declare type loaderOptionsFunc = (type: string) => LoadEntOptions<Ent>;
+export declare abstract class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
     viewer: Viewer;
-    src: EdgeQuerySource<TSource>;
+    src: EdgeQuerySource<TSource, TDest>;
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
-    private idsResolved;
-    private resolvedIDs;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest>);
-    private resolveIDs;
+    constructor(viewer: Viewer, src: EdgeQuerySource<TSource, TDest>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
     private isEdgeQuery;
-    private addID;
+    abstract sourceEnt(id: ID): Promise<Ent | null>;
     private getSingleID;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
     protected loadEntsFromEdges(id: ID, edges: AssocEdge[]): Promise<TDest[]>;
     dataToID(edge: AssocEdge): ID;
-    protected loadRawData(options: EdgeQueryableDataOptions): Promise<void>;
+    protected loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
+    protected loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     queryID2(id2: ID): Promise<TEdge | undefined>;
     queryAllID2(id2: ID): Promise<Map<ID, TEdge>>;
 }
-export interface EdgeQueryCtr<T extends Ent, TEdge extends AssocEdge> {
-    new (viewer: Viewer, src: EdgeQuerySource<T>): EdgeQuery<T, TEdge>;
+export interface EdgeQueryCtr<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> {
+    new (viewer: Viewer, src: EdgeQuerySource<TSource>): EdgeQuery<TSource, TDest, TEdge>;
 }
+export {};

package/core/query/assoc_query.js

@@ -4,34 +4,16 @@ exports.AssocEdgeQueryBase = void 0;
 const ent_1 = require("../ent");
 const query_1 = require("./query");
 class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
-    constructor(viewer, src, countLoaderFactory, dataLoaderFactory, options) {
+    constructor(viewer, src, countLoaderFactory, dataLoaderFactory, 
+    // if function, it's a polymorphic edge and need to provide
+    // a function that goes from edgeType to LoadEntOptions
+    options) {
         super(viewer, "time");
         this.viewer = viewer;
         this.src = src;
         this.countLoaderFactory = countLoaderFactory;
         this.dataLoaderFactory = dataLoaderFactory;
         this.options = options;
-        this.resolvedIDs = [];
-    }
-    // TODO memoization...
-    async resolveIDs() {
-        if (this.idsResolved) {
-            return this.resolvedIDs;
-        }
-        if (Array.isArray(this.src)) {
-            this.src.forEach((obj) => this.addID(obj));
-        }
-        else if (this.isEdgeQuery(this.src)) {
-            const idsMap = await this.src.queryAllIDs();
-            for (const [_, ids] of idsMap) {
-                ids.forEach((id) => this.resolvedIDs.push(id));
-            }
-        }
-        else {
-            this.addID(this.src);
-        }
-        this.idsResolved = true;
-        return this.resolvedIDs;
     }
     isEdgeQuery(obj) {
         if (obj.queryIDs !== undefined) {
@@ -39,70 +21,123 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
         }
         return false;
     }
-    addID(obj) {
-        if (typeof obj === "object") {
-            this.resolvedIDs.push(obj.id);
-        }
-        else {
-            this.resolvedIDs.push(obj);
-        }
-    }
     async getSingleID() {
-        const ids = await this.resolveIDs();
-        if (ids.length !== 1) {
+        const infos = await this.genIDInfosToFetch();
+        if (infos.length !== 1) {
             throw new Error("cannot call queryRawCount when more than one id is requested");
         }
-        return ids[0];
+        return infos[0];
     }
     // doesn't work with filters...
     async queryRawCount() {
-        const id = await this.getSingleID();
-        return this.countLoaderFactory.createLoader(this.viewer.context).load(id);
+        const info = await this.getSingleID();
+        if (info.invalidated) {
+            return 0;
+        }
+        return this.countLoaderFactory
+            .createLoader(this.viewer.context)
+            .load(info.id);
     }
     async queryAllRawCount() {
         let results = new Map();
-        const ids = await this.resolveIDs();
+        const infos = await this.genIDInfosToFetch();
         const loader = this.countLoaderFactory.createLoader(this.viewer.context);
-        await Promise.all(ids.map(async (id) => {
-            const count = await loader.load(id);
-            results.set(id, count);
+        await Promise.all(infos.map(async (info) => {
+            if (info.invalidated) {
+                results.set(info.id, 0);
+                return;
+            }
+            const count = await loader.load(info.id);
+            results.set(info.id, count);
         }));
         return results;
     }
     async loadEntsFromEdges(id, edges) {
+        if (typeof this.options === "function") {
+            const m = new Map();
+            for (const edge of edges) {
+                const nodeType = edge.id2Type;
+                let data = m.get(nodeType);
+                if (data === undefined) {
+                    const opts = this.options(nodeType);
+                    if (opts === undefined) {
+                        throw new Error(`getLoaderOptions returned undefined for type ${nodeType}`);
+                    }
+                    data = {
+                        ids: [],
+                        options: opts,
+                    };
+                }
+                data.ids.push(edge.id2);
+                m.set(nodeType, data);
+            }
+            let promises = [];
+            for (const [_, value] of m) {
+                promises.push((0, ent_1.loadEnts)(this.viewer, value.options, ...value.ids));
+            }
+            const entss = await Promise.all(promises);
+            const r = [];
+            for (const ents of entss) {
+                r.push(...ents);
+            }
+            return r;
+        }
         const ids = edges.map((edge) => edge.id2);
-        return await ent_1.loadEnts(this.viewer, this.options, ...ids);
+        return await (0, ent_1.loadEnts)(this.viewer, this.options, ...ids);
     }
     dataToID(edge) {
         return edge.id2;
     }
-    async loadRawData(options) {
-        const ids = await this.resolveIDs();
+    async loadRawIDs(addID) {
+        if (Array.isArray(this.src)) {
+            this.src.forEach((obj) => addID(obj));
+        }
+        else if (this.isEdgeQuery(this.src)) {
+            const idsMap = await this.src.queryAllIDs();
+            for (const [_, ids] of idsMap) {
+                ids.forEach((id) => addID(id));
+            }
+        }
+        else {
+            addID(this.src);
+        }
+    }
+    async loadRawData(infos, options) {
         const loader = this.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
-        await Promise.all(ids.map(async (id) => {
+        await Promise.all(infos.map(async (info) => {
+            if (info.invalidated) {
+                this.edges.set(info.id, []);
+                return;
+            }
             // there'll be filters for special edges here...
             // and then depending on that, we use this
             // what happens if you do first(10).id2(XX)
             // doesn't make sense
             // so only makes sense if one of these...
             // Id2 needs to be an option
-            const edges = await loader.load(id);
-            this.edges.set(id, edges);
+            const edges = await loader.load(info.id);
+            this.edges.set(info.id, edges);
         }));
     }
     async queryID2(id2) {
-        const id = await this.getSingleID();
+        const info = await this.getSingleID();
+        if (info.invalidated) {
+            return;
+        }
         const loader = this.dataLoaderFactory.createLoader(this.viewer.context);
-        return loader.loadEdgeForID2(id, id2);
+        return loader.loadEdgeForID2(info.id, id2);
     }
     async queryAllID2(id2) {
-        const ids = await this.resolveIDs();
+        const infos = await this.genIDInfosToFetch();
         const loader = this.dataLoaderFactory.createLoader(this.viewer.context);
         const m = new Map();
-        await Promise.all(ids.map(async (id) => {
-            const edge = await loader.loadEdgeForID2(id, id2);
+        await Promise.all(infos.map(async (info) => {
+            if (info.invalidated) {
+                return;
+            }
+            const edge = await loader.loadEdgeForID2(info.id, id2);
             if (edge) {
-                m.set(id, edge);
+                m.set(info.id, edge);
             }
         }));
         return m;

package/core/query/custom_query.d.ts

@@ -1,20 +1,23 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
-import { BaseEdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<T extends Ent> {
-    src: Ent | ID;
+import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
+export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+    src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
-    options: LoadEntOptions<T>;
+    options: LoadEntOptions<TDest>;
     sortColumn?: string;
 }
-export declare class CustomEdgeQueryBase<TDest extends Ent> extends BaseEdgeQuery<TDest, Data> {
+export declare abstract class CustomEdgeQueryBase<TSource extends Ent, TDest extends Ent> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
     viewer: Viewer;
     private options;
     private id;
-    constructor(viewer: Viewer, options: CustomEdgeQueryOptions<TDest>);
+    constructor(viewer: Viewer, options: CustomEdgeQueryOptions<TSource, TDest>);
+    abstract sourceEnt(id: ID): Promise<Ent | null>;
+    private idVisible;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
-    protected loadRawData(options: EdgeQueryableDataOptions): Promise<void>;
+    protected loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
+    protected loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     dataToID(edge: Data): ID;
     protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;
 }

package/core/query/custom_query.js

@@ -16,16 +16,34 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
             this.id = options.src;
         }
     }
+    async idVisible() {
+        const ids = await this.genIDInfosToFetch();
+        if (ids.length !== 1) {
+            throw new Error("invalid number of IDInfo");
+        }
+        return !ids[0].invalidated;
+    }
     async queryRawCount() {
+        const idVisible = await this.idVisible();
+        if (!idVisible) {
+            return 0;
+        }
         return await this.options.countLoaderFactory
             .createLoader(this.viewer.context)
             .load(this.id);
     }
     async queryAllRawCount() {
-        const count = await this.queryRawCount();
+        let count = 0;
+        const idVisible = await this.idVisible();
+        if (idVisible) {
+            count = await this.queryRawCount();
+        }
         return new Map([[this.id, count]]);
     }
-    async loadRawData(options) {
+    async loadRawIDs(addID) {
+        addID(this.options.src);
+    }
+    async loadRawData(infos, options) {
         const loader = this.options.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
         if (!options.orderby) {
             options.orderby = `${this.options.sortColumn} DESC`;
@@ -33,6 +51,14 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         if (!options.limit) {
             options.limit = ent_1.DefaultLimit;
         }
+        if (infos.length !== 1) {
+            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
+        }
+        const info = infos[0];
+        if (info.invalidated) {
+            this.edges.set(this.id, []);
+            return;
+        }
         const rows = await loader.load(this.id);
         this.edges.set(this.id, rows);
     }
@@ -40,7 +66,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         return edge.id;
     }
     async loadEntsFromEdges(id, rows) {
-        const ents = await ent_1.applyPrivacyPolicyForRows(this.viewer, rows, this.options.options);
+        const ents = await (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.options);
         return Array.from(ents.values());
     }
 }