@snowtop/ent 0.1.0-alpha3 → 0.1.0-alpha30

package/core/ent.js

@@ -22,8 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.loadEdges = exports.defaultEdgeQueryOptions = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.EditNodeOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.applyPrivacyPolicyForEntX = exports.applyPrivacyPolicyForEnt = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = void 0;
-exports.getEdgeTypeInGroup = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.loadEdges = exports.defaultEdgeQueryOptions = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.EditNodeOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const clause = __importStar(require("./clause"));
@@ -62,6 +61,7 @@ function createDataLoader(options) {
     if ((0, logger_1.logEnabled)("query")) {
         loaderOptions.cacheMap = new cacheMap(options);
     }
+    // something here brokwn with strict:true
     return new dataloader_1.default(async (ids) => {
         if (!ids.length) {
             return [];
@@ -140,8 +140,7 @@ async function loadEntXFromClause(viewer, options, clause) {
         context: viewer.context,
     };
     const row = await loadRowX(rowOptions);
-    const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEntX(viewer, ent);
+    return await applyPrivacyPolicyForRowX(viewer, options, row);
 }
 exports.loadEntXFromClause = loadEntXFromClause;
 async function loadEnts(viewer, options, ...ids) {
@@ -212,7 +211,7 @@ async function loadCustomEnts(viewer, options, query) {
     const result = new Array(rows.length);
     await Promise.all(rows.map(async (row, idx) => {
         const ent = new options.ent(viewer, row);
-        let privacyEnt = await applyPrivacyPolicyForEnt(viewer, ent);
+        let privacyEnt = await applyPrivacyPolicyForEnt(viewer, ent, row, options);
         if (privacyEnt) {
             result[idx] = privacyEnt;
         }
@@ -258,30 +257,60 @@ exports.loadCustomData = loadCustomData;
 // Derived ents
 async function loadDerivedEnt(viewer, data, loader) {
     const ent = new loader(viewer, data);
-    return await applyPrivacyPolicyForEnt(viewer, ent);
+    return await applyPrivacyPolicyForEnt(viewer, ent, data, {
+        ent: loader,
+    });
 }
 exports.loadDerivedEnt = loadDerivedEnt;
 async function loadDerivedEntX(viewer, data, loader) {
     const ent = new loader(viewer, data);
-    return await applyPrivacyPolicyForEntX(viewer, ent);
+    return await applyPrivacyPolicyForEntX(viewer, ent, data, { ent: loader });
 }
 exports.loadDerivedEntX = loadDerivedEntX;
-async function applyPrivacyPolicyForEnt(viewer, ent) {
+// everything calls into this two so should be fine
+// TODO is there a smarter way to not instantiate two objects here?
+async function applyPrivacyPolicyForEnt(viewer, ent, data, fieldPrivacyOptions) {
     if (ent) {
-        const visible = await (0, privacy_1.applyPrivacyPolicy)(viewer, ent.privacyPolicy, ent);
-        if (visible) {
-            return ent;
+        const visible = await (0, privacy_1.applyPrivacyPolicy)(viewer, ent.getPrivacyPolicy(), ent);
+        if (!visible) {
+            return null;
         }
+        return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
     }
     return null;
 }
-exports.applyPrivacyPolicyForEnt = applyPrivacyPolicyForEnt;
-async function applyPrivacyPolicyForEntX(viewer, ent) {
+async function applyPrivacyPolicyForEntX(viewer, ent, data, options) {
     // this will throw
-    await (0, privacy_1.applyPrivacyPolicyX)(viewer, ent.privacyPolicy, ent);
+    await (0, privacy_1.applyPrivacyPolicyX)(viewer, ent.getPrivacyPolicy(), ent);
+    return doFieldPrivacy(viewer, ent, data, options);
+}
+async function doFieldPrivacy(viewer, ent, data, options) {
+    if (!options.fieldPrivacy) {
+        return ent;
+    }
+    const promises = [];
+    let somethingChanged = false;
+    for (const [k, policy] of options.fieldPrivacy) {
+        promises.push((async () => {
+            // don't do anything if key is null or for some reason missing
+            const curr = data[k];
+            if (curr === null || curr === undefined) {
+                return;
+            }
+            const r = await (0, privacy_1.applyPrivacyPolicy)(viewer, policy, ent);
+            if (!r) {
+                data[k] = null;
+                somethingChanged = true;
+            }
+        })());
+    }
+    await Promise.all(promises);
+    if (somethingChanged) {
+        // have to create new instance
+        return new options.ent(viewer, data);
+    }
     return ent;
 }
-exports.applyPrivacyPolicyForEntX = applyPrivacyPolicyForEntX;
 function logQuery(query, logValues) {
     (0, logger_1.log)("query", {
         query: query,
@@ -327,6 +356,8 @@ async function loadRow(options) {
         return res.rows[0];
     }
     catch (e) {
+        // an example of an error being suppressed
+        // another one. TODO https://github.com/lolopinto/ent/issues/862
         (0, logger_1.log)("error", e);
         return null;
     }
@@ -406,6 +437,7 @@ class EditNodeOperation {
     constructor(options, existingEnt = null) {
         this.options = options;
         this.existingEnt = existingEnt;
+        this.row = null;
         this.placeholderID = options.placeholderID;
     }
     resolve(executor) {
@@ -439,9 +471,12 @@ class EditNodeOperation {
         };
         if (this.existingEnt) {
             if (this.hasData(options.fields)) {
+                // even this with returning * may not always work if transformed...
+                // we can have a transformed flag to see if it should be returned?
                 this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
             }
             else {
+                // @ts-ignore
                 this.row = this.existingEnt["data"];
             }
         }
@@ -450,20 +485,36 @@ class EditNodeOperation {
         }
     }
     reloadRow(queryer, id, options) {
+        // TODO this isn't always an ObjectLoader. should throw or figure out a way to get query
+        // and run this on its own...
+        const loader = this.options.loadEntOptions.loaderFactory.createLoader(options.context);
+        const opts = loader.getOptions();
+        let cls = clause.Eq(options.key, id);
+        if (opts.clause) {
+            let optionClause;
+            if (typeof opts.clause === "function") {
+                optionClause = opts.clause();
+            }
+            else {
+                optionClause = opts.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(optionClause, cls);
+            }
+        }
         const query = buildQuery({
-            fields: ["*"],
+            fields: opts.fields.length ? opts.fields : ["*"],
             tableName: options.tableName,
-            clause: clause.Eq(options.key, id),
+            clause: cls,
         });
         // special case log here because we're not going through any of the normal
         // methods here because those are async and this is sync
         // this is the only place we're doing this so only handling here
         logQuery(query, [id]);
         const r = queryer.querySync(query, [id]);
-        if (r.rows.length !== 1) {
-            throw new Error(`couldn't reload row for ${id}`);
+        if (r.rows.length === 1) {
+            this.row = r.rows[0];
         }
-        this.row = r.rows[0];
     }
     performWriteSync(queryer, context) {
         let options = {
@@ -476,6 +527,7 @@ class EditNodeOperation {
                 this.reloadRow(queryer, this.existingEnt.id, options);
             }
             else {
+                // @ts-ignore
                 this.row = this.existingEnt["data"];
             }
         }
@@ -492,7 +544,7 @@ class EditNodeOperation {
         if (!this.row) {
             return null;
         }
-        return new this.options.ent(viewer, this.row);
+        return new this.options.loadEntOptions.ent(viewer, this.row);
     }
 }
 exports.EditNodeOperation = EditNodeOperation;
@@ -1146,20 +1198,19 @@ async function applyPrivacyPolicyForRow(viewer, options, row) {
         return null;
     }
     const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEnt(viewer, ent);
+    return await applyPrivacyPolicyForEnt(viewer, ent, row, options);
 }
 exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
 async function applyPrivacyPolicyForRowX(viewer, options, row) {
     const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEntX(viewer, ent);
+    return await applyPrivacyPolicyForEntX(viewer, ent, row, options);
 }
 exports.applyPrivacyPolicyForRowX = applyPrivacyPolicyForRowX;
 async function applyPrivacyPolicyForRows(viewer, rows, options) {
     let m = new Map();
     // apply privacy logic
     await Promise.all(rows.map(async (row) => {
-        const ent = new options.ent(viewer, row);
-        let privacyEnt = await applyPrivacyPolicyForEnt(viewer, ent);
+        let privacyEnt = await applyPrivacyPolicyForRow(viewer, options, row);
         if (privacyEnt) {
             m.set(privacyEnt.id, privacyEnt);
         }

package/core/loaders/assoc_count_loader.d.ts

@@ -1,10 +1,10 @@
 import { ID, Context, Loader, LoaderFactory } from "../base";
 export declare class AssocEdgeCountLoader implements Loader<ID, number> {
     private edgeType;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private loaderFn;
     private loader;
-    constructor(edgeType: string, context?: Context | undefined);
+    constructor(edgeType: string, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private getLoader;
     load(id: ID): Promise<number>;
     clearAll(): void;

package/core/loaders/assoc_edge_loader.d.ts

@@ -20,8 +20,8 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeType;
     private edgeCtr;
     private options?;
-    context?: Context | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context | undefined);
+    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, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;
@@ -32,7 +32,7 @@ export declare class AssocEdgeLoaderFactory<T extends AssocEdge> implements Load
     name: string;
     constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T> | (() => AssocEdgeConstructor<T>));
     createLoader(context?: Context): AssocLoader<T>;
-    private isFunction;
+    private isConstructor;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): AssocLoader<T>;
 }
 export {};

package/core/loaders/assoc_edge_loader.js

@@ -161,16 +161,17 @@ class AssocEdgeLoaderFactory {
     createLoader(context) {
         return this.createConfigurableLoader({}, context);
     }
-    isFunction(edgeCtr) {
-        // not constructor
-        return !(edgeCtr.prototype && edgeCtr.prototype.constructor === edgeCtr);
+    isConstructor(edgeCtr) {
+        return (edgeCtr.prototype &&
+            edgeCtr.prototype.constructor &&
+            edgeCtr.prototype.constructor.name.length > 0);
     }
     createConfigurableLoader(options, context) {
         let edgeCtr = this.edgeCtr;
         // in generated code, the edge is not necessarily defined at the time of loading
         // so we call this as follows:
         // const loader = new AssocEdgeLoaderFactory(EdgeType.Foo, ()=>DerivedEdgeClass);
-        if (this.isFunction(edgeCtr)) {
+        if (!this.isConstructor(edgeCtr)) {
             edgeCtr = edgeCtr();
         }
         // rename to make TS happy

package/core/loaders/index_loader.js

@@ -4,6 +4,7 @@ exports.IndexLoaderFactory = void 0;
 const query_loader_1 = require("./query_loader");
 // we're keeping this for legacy reasons so as to not break existing callers
 // and to decouple the change here but all callers can safely be changed here to use QueryLoaderFactory
+// @deprecated use QueryLoaderFactory
 class IndexLoaderFactory {
     constructor(options, col, opts) {
         this.factory = new query_loader_1.QueryLoaderFactory({

package/core/loaders/object_loader.d.ts

@@ -1,23 +1,28 @@
-import { Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
+import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
 export declare class ObjectLoader<T> implements Loader<T, Data | null> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private toPrime?;
     private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    getOptions(): SelectDataOptions;
     private initPrime;
     load(key: T): Promise<Data | null>;
     clearAll(): void;
     loadMany(keys: T[]): Promise<Data[]>;
     prime(data: Data): void;
 }
+interface ObjectLoaderOptions extends SelectDataOptions {
+    instanceKey?: string;
+}
 export declare class ObjectLoaderFactory<T> implements LoaderFactory<T, Data | null> {
-    options: SelectDataOptions;
+    options: ObjectLoaderOptions;
     name: string;
     private toPrime;
-    constructor(options: SelectDataOptions);
+    constructor(options: ObjectLoaderOptions);
     createLoader(context?: Context): ObjectLoader<T>;
     addToPrime(factory: ObjectLoaderFactory<T>): void;
 }
+export {};

package/core/loaders/object_loader.js

@@ -29,6 +29,9 @@ const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
+// optional clause...
+// so ObjectLoaderFactory and createDataLoader need to take a new optional field which is a clause that's always added here
+// and we need a disableTransform which skips loader completely and uses loadRow...
 function createDataLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
@@ -40,9 +43,22 @@ function createDataLoader(options) {
             return [];
         }
         let col = options.key;
+        let cls = clause.In(col, ...ids);
+        if (options.clause) {
+            let optionClause;
+            if (typeof options.clause === "function") {
+                optionClause = options.clause();
+            }
+            else {
+                optionClause = options.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(optionClause, cls);
+            }
+        }
         const rowOptions = {
             ...options,
-            clause: clause.In(col, ...ids),
+            clause: cls,
         };
         let m = new Map();
         let result = [];
@@ -77,6 +93,9 @@ class ObjectLoader {
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
+    getOptions() {
+        return this.options;
+    }
     initPrime() {
         if (!this.context || !this.toPrime) {
             return;
@@ -107,9 +126,22 @@ class ObjectLoader {
             }
             return result;
         }
+        let cls = clause.Eq(this.options.key, key);
+        if (this.options.clause) {
+            let optionClause;
+            if (typeof this.options.clause === "function") {
+                optionClause = this.options.clause();
+            }
+            else {
+                optionClause = this.options.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(optionClause, cls);
+            }
+        }
         const rowOptions = {
             ...this.options,
-            clause: clause.Eq(this.options.key, key),
+            clause: cls,
             context: this.context,
         };
         return await (0, ent_1.loadRow)(rowOptions);
@@ -121,9 +153,22 @@ class ObjectLoader {
         if (this.loader) {
             return await this.loader.loadMany(keys);
         }
+        let cls = clause.In(this.options.key, ...keys);
+        if (this.options.clause) {
+            let optionClause;
+            if (typeof this.options.clause === "function") {
+                optionClause = this.options.clause();
+            }
+            else {
+                optionClause = this.options.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(optionClause, cls);
+            }
+        }
         const rowOptions = {
             ...this.options,
-            clause: clause.In(this.options.key, ...keys),
+            clause: cls,
             context: this.context,
         };
         return await (0, ent_1.loadRows)(rowOptions);
@@ -142,7 +187,17 @@ class ObjectLoaderFactory {
     constructor(options) {
         this.options = options;
         this.toPrime = [];
-        this.name = `${options.tableName}:${options.key}`;
+        // we don't wanna do it here because we want it to be delayed
+        let instanceKey = "";
+        if (typeof this.options.clause === "function") {
+            if (!options.instanceKey) {
+                throw new Error(`need to pass an instanceKey to ObjectLoader if clause is a function`);
+            }
+        }
+        else if (this.options.clause) {
+            instanceKey = this.options.clause.instanceKey();
+        }
+        this.name = `${options.tableName}:${options.key}:${instanceKey}`;
     }
     createLoader(context) {
         return (0, loader_1.getLoader)(this, () => {

package/core/loaders/query_loader.d.ts

@@ -10,12 +10,12 @@ export declare class QueryDirectLoader<K extends any> implements Loader<K, Data[
 }
 export declare class QueryLoader<K extends any> implements Loader<K, Data[]> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private queryOptions?;
     private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: QueryOptions, context?: Context | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
+    constructor(options: QueryOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;

package/core/loaders/raw_count_loader.d.ts

@@ -9,9 +9,9 @@ interface QueryCountOptions {
 export declare function createCountDataLoader<K extends any>(options: QueryCountOptions): DataLoader<K, number, K>;
 export declare class RawCountLoader<K extends any> implements Loader<K, number> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private loader;
-    constructor(options: QueryCountOptions, context?: Context | undefined);
+    constructor(options: QueryCountOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: K): Promise<number>;
     clearAll(): void;
 }

package/core/privacy.d.ts

@@ -6,22 +6,22 @@ export declare class EntPrivacyError extends Error implements PrivacyError {
     constructor(privacyPolicy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent);
 }
 export declare const AlwaysAllowRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AlwaysDenyRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedOutRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedInRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfHasIdentity: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfViewerRule: {
-    apply(v: Viewer, ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare class AllowIfViewerEqualsRule {
     private id;
@@ -71,45 +71,45 @@ export declare class DenyIfEntPropertyIsRule<T extends Ent> implements PrivacyPo
     constructor(property: keyof T, val: any);
     apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class AllowIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class DenyIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class DenyIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
@@ -121,7 +121,7 @@ export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
 export declare class AllowIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
     constructor(edgeType: string);
-    apply(v: Viewer, ent: Ent): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;

package/core/privacy.js

@@ -464,6 +464,9 @@ async function applyPrivacyPolicyX(v, policy, ent, throwErr) {
             if (res.error) {
                 throw res.error;
             }
+            if (res.getError) {
+                throw res.getError(policy, rule, ent);
+            }
             if (throwErr) {
                 throw throwErr();
             }

package/core/query/assoc_query.d.ts

@@ -3,15 +3,15 @@ import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
 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, TDest>;
+export declare type EdgeQuerySource<TSource extends Ent<TViewer>, TDest extends Ent<TViewer> = Ent<any>, TViewer extends Viewer = Viewer> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
+declare type loaderOptionsFunc<TViewer extends Viewer> = (type: string) => LoadEntOptions<Ent, TViewer>;
+export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TEdge extends AssocEdge, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
+    viewer: TViewer;
+    src: EdgeQuerySource<TSource, TDest, TViewer>;
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource, TDest>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
+    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>;
     private getSingleID;

package/core/query/custom_query.d.ts

@@ -1,17 +1,17 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
-    options: LoadEntOptions<TDest>;
+    options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
-export declare abstract class CustomEdgeQueryBase<TSource extends Ent, TDest extends Ent> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
-    viewer: Viewer;
+export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
+    viewer: TViewer;
     private options;
     private id;
-    constructor(viewer: Viewer, options: CustomEdgeQueryOptions<TSource, TDest>);
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptions<TSource, TDest, TViewer>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
     queryRawCount(): Promise<number>;

package/core/query/query.d.ts

@@ -41,7 +41,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private idMap;
     private idsToFetch;
     constructor(viewer: Viewer, sortCol: string);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    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;
     last(n: number, before?: string): this;

package/core/viewer.d.ts

@@ -1,7 +1,7 @@
 import { ID, Ent, Viewer, Context } from "./base";
 export declare class LoggedOutViewer implements Viewer {
-    context?: Context | undefined;
-    constructor(context?: Context | undefined);
+    context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined;
+    constructor(context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined);
     viewerID: null;
     viewer(): Promise<null>;
     instanceKey(): string;
@@ -17,6 +17,7 @@ export declare class IDViewer implements Viewer {
     context?: Context;
     constructor(viewerID: ID, opts?: Partial<IDViewerOptions>);
     constructor(opts: IDViewerOptions);
-    viewer(): Promise<Ent | null>;
+    setContext(ctx: Context): this;
+    viewer(): Promise<Ent<Viewer<Ent<any> | null, ID | null>> | null>;
     instanceKey(): string;
 }