@snowtop/ent 0.0.22 → 0.0.28-alpha

package/action/executor.d.ts

@@ -1,4 +1,4 @@
-import { ID, Ent, Viewer, EntConstructor, Context } from "../core/base";
+import { ID, Data, Ent, Viewer, EntConstructor, Context } from "../core/base";
 import { DataOperation } from "../core/ent";
 import { Changeset, Executor } from "../action";
 import { Builder } from "../action";
@@ -11,7 +11,7 @@ export declare class ListBasedExecutor<T extends Ent> implements Executor {
     private operations;
     private options?;
     private idx;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], options?: OrchestratorOptions<T> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], options?: OrchestratorOptions<T, Data> | undefined);
     private lastOp;
     private createdEnt;
     resolveValue(val: ID): Ent | null;
@@ -34,7 +34,7 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     private changesetMap;
     private nodeOpMap;
     private executors;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset<T>[], options?: OrchestratorOptions<T> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset<T>[], options?: OrchestratorOptions<T, Data> | undefined);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation>;

package/action/orchestrator.d.ts

@@ -3,7 +3,7 @@ import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
 import { SchemaInputType } from "../schema/schema";
 import { Changeset, Executor } from "../action";
 import { WriteOperation, Builder, Action } from "../action";
-export interface OrchestratorOptions<T extends Ent> {
+export interface OrchestratorOptions<T extends Ent, TData extends Data> {
     viewer: Viewer;
     operation: WriteOperation;
     tableName: string;
@@ -13,6 +13,7 @@ export interface OrchestratorOptions<T extends Ent> {
     action?: Action<T>;
     schema: SchemaInputType;
     editedFields(): Map<string, any>;
+    updateInput?: (data: TData) => void;
 }
 interface edgeInputDataOpts {
     edgeType: string;
@@ -38,7 +39,9 @@ export declare class Orchestrator<T extends Ent> {
     private fieldsToResolve;
     private mainOp;
     viewer: Viewer;
-    constructor(options: OrchestratorOptions<T>);
+    private defaultFieldsByFieldName;
+    private defaultFieldsByTSName;
+    constructor(options: OrchestratorOptions<T, Data>);
     private addEdge;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
@@ -50,11 +53,13 @@ export declare class Orchestrator<T extends Ent> {
     private getEdgeOperation;
     private buildEdgeOps;
     private throwError;
+    private getEntForPrivacyPolicy;
     private validate;
     private triggers;
     private validators;
     private isBuilder;
-    private validateFields;
+    private getFieldsWithDefaultValues;
+    private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     build(): Promise<EntChangeset<T>>;
@@ -71,7 +76,7 @@ export declare class EntChangeset<T extends Ent> implements Changeset<T> {
     dependencies?: Map<ID, Builder<T>> | undefined;
     changesets?: Changeset<Ent>[] | undefined;
     private options?;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<T>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<T>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T, Data> | undefined);
     executor(): Executor;
 }
 export {};

package/action/orchestrator.js

@@ -5,6 +5,7 @@ const ent_1 = require("../core/ent");
 const schema_1 = require("../schema/schema");
 const action_1 = require("../action");
 const snake_case_1 = require("snake-case");
+const camel_case_1 = require("camel-case");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
 const logger_1 = require("../core/logger");
@@ -58,6 +59,8 @@ class Orchestrator {
         this.changesets = [];
         this.dependencies = new Map();
         this.fieldsToResolve = [];
+        this.defaultFieldsByFieldName = {};
+        this.defaultFieldsByTSName = {};
         this.viewer = options.viewer;
     }
     addEdge(edge, op) {
@@ -222,16 +225,35 @@ class Orchestrator {
         }
         return new EntCannotDeleteEntError(privacyPolicy, action, this.options.builder.existingEnt);
     }
+    getEntForPrivacyPolicy(editedData) {
+        if (this.options.operation !== action_1.WriteOperation.Insert) {
+            return this.options.builder.existingEnt;
+        }
+        // we create an unsafe ent to be used for privacy policies
+        return new this.options.builder.ent(this.options.builder.viewer, editedData);
+    }
     async validate() {
+        // existing ent required for edit or delete operations
+        switch (this.options.operation) {
+            case action_1.WriteOperation.Delete:
+            case action_1.WriteOperation.Edit:
+                if (!this.options.builder.existingEnt) {
+                    throw new Error("existing ent required with operation");
+                }
+        }
         const action = this.options.action;
         const builder = this.options.builder;
-        // this runs in 3 phases:
-        // * privacy policy
+        // future optimization: can get schemaFields to memoize based on different values
+        const schemaFields = (0, schema_1.getFields)(this.options.schema);
+        let editedData = this.getFieldsWithDefaultValues(builder, schemaFields, action);
+        // this runs in following phases:
+        // * set default fields and pass to builder so the value can be checked by triggers/observers/validators
+        // * privacy policy (use unsafe ent if we have it)
         // * triggers
         // * validators
         let privacyPolicy = action?.getPrivacyPolicy();
         if (privacyPolicy) {
-            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, builder.existingEnt, this.throwError.bind(this));
+            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicy(editedData), this.throwError.bind(this));
         }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
@@ -241,7 +263,7 @@ class Orchestrator {
         }
         let validators = action?.validators || [];
         await Promise.all([
-            this.validateFields(builder, action),
+            this.formatAndValidateFields(schemaFields),
             this.validators(validators, action, builder),
         ]);
     }
@@ -276,29 +298,14 @@ class Orchestrator {
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
-    async validateFields(builder, action) {
-        // existing ent required for edit or delete operations
-        switch (this.options.operation) {
-            case action_1.WriteOperation.Delete:
-            case action_1.WriteOperation.Edit:
-                if (!this.options.builder.existingEnt) {
-                    throw new Error("existing ent required with operation");
-                }
-        }
-        if (this.options.operation == action_1.WriteOperation.Delete) {
-            return;
-        }
+    getFieldsWithDefaultValues(builder, schemaFields, action) {
         const editedFields = this.options.editedFields();
-        // build up data to be saved...
         let data = {};
-        let logValues = {};
-        const schemaFields = (0, schema_1.getFields)(this.options.schema);
-        let input = {};
-        if (action !== undefined) {
-            input = action.getInput();
-        }
+        let input = action?.getInput() || {};
+        let updateInput = false;
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
+            let defaultValue = undefined;
             let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
             if (value === undefined) {
                 if (this.options.operation === action_1.WriteOperation.Insert) {
@@ -306,18 +313,52 @@ class Orchestrator {
                         throw new Error(`cannot set both defaultToViewerOnCreate and defaultValueOnCreate`);
                     }
                     if (field.defaultToViewerOnCreate) {
-                        value = builder.viewer.viewerID;
+                        defaultValue = builder.viewer.viewerID;
                     }
                     if (field.defaultValueOnCreate) {
-                        value = field.defaultValueOnCreate(builder, input);
+                        defaultValue = field.defaultValueOnCreate(builder, input);
+                        if (defaultValue === undefined) {
+                            throw new Error(`defaultValueOnCreate() returned undefined for field ${field.name}`);
+                        }
                     }
                 }
                 if (field.defaultValueOnEdit &&
                     this.options.operation === action_1.WriteOperation.Edit) {
-                    value = field.defaultValueOnEdit(builder, input);
-                    // TODO special case this if this is the onlything changing and don't do the write.
+                    defaultValue = field.defaultValueOnEdit(builder, input);
+                    // TODO special case this if this is the only thing changing and don't do the write.
                 }
             }
+            data[dbKey] = value;
+            if (defaultValue !== undefined) {
+                updateInput = true;
+                data[dbKey] = defaultValue;
+                this.defaultFieldsByFieldName[fieldName] = defaultValue;
+                // TODO related to #510. we need this logic to be consistent so do this all in TypeScript or get it from go somehow
+                this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(fieldName)] = defaultValue;
+            }
+        }
+        if (updateInput && this.options.updateInput) {
+            // this basically fixes #605. just needs to be exposed correctly
+            this.options.updateInput(this.defaultFieldsByTSName);
+        }
+        return data;
+    }
+    async formatAndValidateFields(schemaFields) {
+        if (this.options.operation == action_1.WriteOperation.Delete) {
+            return;
+        }
+        const editedFields = this.options.editedFields();
+        // build up data to be saved...
+        let data = {};
+        let logValues = {};
+        for (const [fieldName, field] of schemaFields) {
+            let value = editedFields.get(fieldName);
+            if (value === undefined) {
+                // null allowed
+                value = this.defaultFieldsByFieldName[fieldName];
+            }
+            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+            // now format and validate...
             if (value === null) {
                 if (!field.nullable) {
                     throw new Error(`field ${field.name} set to null for non-nullable field`);
@@ -361,7 +402,6 @@ class Orchestrator {
         }
         this.validatedFields = data;
         this.logValues = logValues;
-        //    console.log(this.validatedFields);
     }
     async valid() {
         try {
@@ -389,7 +429,7 @@ class Orchestrator {
         if (!action || !action.viewerForEntLoad) {
             return this.options.viewer;
         }
-        return await action.viewerForEntLoad(data);
+        return action.viewerForEntLoad(data);
     }
     async returnedRow() {
         if (this.mainOp && this.mainOp.returnedEntRow) {
@@ -403,7 +443,7 @@ class Orchestrator {
             return null;
         }
         const viewer = await this.viewerForEntLoad(row);
-        return await (0, ent_1.applyPrivacyPolicyForRow)(viewer, this.options.loaderOptions, row);
+        return (0, ent_1.applyPrivacyPolicyForRow)(viewer, this.options.loaderOptions, row);
     }
     async editedEntX() {
         const row = await this.returnedRow();

package/core/base.js

@@ -9,22 +9,25 @@ var privacyResult;
     privacyResult[privacyResult["Deny"] = 401] = "Deny";
     privacyResult[privacyResult["Skip"] = 307] = "Skip";
 })(privacyResult || (privacyResult = {}));
+const allow = {
+    result: privacyResult.Allow,
+};
 function Allow() {
-    return {
-        result: privacyResult.Allow,
-    };
+    return allow;
 }
 exports.Allow = Allow;
+const skip = {
+    result: privacyResult.Skip,
+};
 function Skip() {
-    return {
-        result: privacyResult.Skip,
-    };
+    return skip;
 }
 exports.Skip = Skip;
+const deny = {
+    result: privacyResult.Deny,
+};
 function Deny() {
-    return {
-        result: privacyResult.Deny,
-    };
+    return deny;
 }
 exports.Deny = Deny;
 function DenyWithReason(e) {

package/core/config.d.ts

@@ -15,6 +15,8 @@ interface CodegenConfig {
     relativeImports?: boolean;
     disableGraphQLRoot?: boolean;
     generatedHeader?: string;
+    disableBase64Encoding?: boolean;
+    generateRootResolvers?: boolean;
 }
 interface PrettierConfig {
     custom?: boolean;

package/core/convert.js

@@ -59,7 +59,8 @@ function convertList(val, conv) {
 }
 exports.convertList = convertList;
 function convertNullableList(val, conv) {
-    if (val === null) {
+    // undefined can happen with unsafe ents
+    if (val === null || val === undefined) {
         return null;
     }
     return convertList(val, conv);

package/core/privacy.d.ts

@@ -1,4 +1,4 @@
-import { Viewer, ID, Ent, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult } from "./base";
+import { Ent, ID, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult, Viewer } from "./base";
 export declare class EntPrivacyError extends Error implements PrivacyError {
     privacyPolicy: PrivacyPolicy;
     privacyRule: PrivacyPolicyRule;
@@ -46,11 +46,31 @@ export declare class DenyIfFuncRule implements PrivacyPolicyRule {
     constructor(fn: FuncRule);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
+/**
+ * @deprecated use AllowIfViewerIsEntPropertyRule
+ */
 export declare class AllowIfViewerIsRule implements PrivacyPolicyRule {
     private property;
     constructor(property: string);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
+export declare class AllowIfViewerIsEntPropertyRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    constructor(property: keyof T);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
+export declare class AllowIfEntPropertyIsRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private val;
+    constructor(property: keyof T, val: any);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
+export declare class DenyIfEntPropertyIsRule<T extends Ent> implements PrivacyPolicyRule {
+    private property;
+    private val;
+    constructor(property: keyof T, val: any);
+    apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
+}
 export declare class AllowIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
     private id;
     private options;

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");
@@ -124,6 +124,9 @@ class DenyIfFuncRule {
     }
 }
 exports.DenyIfFuncRule = DenyIfFuncRule;
+/**
+ * @deprecated use AllowIfViewerIsEntPropertyRule
+ */
 class AllowIfViewerIsRule {
     constructor(property) {
         this.property = property;
@@ -140,6 +143,47 @@ class AllowIfViewerIsRule {
     }
 }
 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;

package/core/query/assoc_query.d.ts

@@ -2,31 +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, Ent, AssocEdge>;
+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 class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TDest, TEdge> {
+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> | loaderOptionsFunc);
-    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, Ent, 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

@@ -14,27 +14,6 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
         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) {
@@ -42,33 +21,34 @@ 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;
     }
@@ -108,33 +88,56 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
     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[]>;
 }