@snowtop/ent 0.1.0-alpha9 → 0.1.0-alpha90

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_count_loader.js

@@ -41,10 +41,15 @@ class AssocEdgeCountLoader {
         if (!edgeData) {
             throw new Error(`error loading edge data for ${this.edgeType}`);
         }
+        const { cls } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", this.edgeType), {
+            // don't need this..
+            id1: "1",
+            edgeType: this.edgeType,
+        });
         this.loader = (0, raw_count_loader_1.createCountDataLoader)({
             tableName: edgeData.edgeTable,
             groupCol: "id1",
-            clause: clause.Eq("edge_type", this.edgeType),
+            clause: cls,
         });
         return this.loader;
     }

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;

package/core/loaders/index.d.ts

@@ -3,4 +3,4 @@ export { RawCountLoader, RawCountLoaderFactory } from "./raw_count_loader";
 export { AssocEdgeCountLoader, AssocEdgeCountLoaderFactory, } from "./assoc_count_loader";
 export { AssocDirectEdgeLoader, AssocEdgeLoader, AssocEdgeLoaderFactory, } from "./assoc_edge_loader";
 export { IndexLoaderFactory } from "./index_loader";
-export { QueryLoader, QueryDirectLoader, QueryLoaderFactory, } from "./query_loader";
+export { QueryLoaderFactory } from "./query_loader";

package/core/loaders/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.QueryDirectLoader = exports.QueryLoader = exports.IndexLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
+exports.QueryLoaderFactory = exports.IndexLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
 var object_loader_1 = require("./object_loader");
 Object.defineProperty(exports, "ObjectLoader", { enumerable: true, get: function () { return object_loader_1.ObjectLoader; } });
 Object.defineProperty(exports, "ObjectLoaderFactory", { enumerable: true, get: function () { return object_loader_1.ObjectLoaderFactory; } });
@@ -17,6 +17,4 @@ Object.defineProperty(exports, "AssocEdgeLoaderFactory", { enumerable: true, get
 var index_loader_1 = require("./index_loader");
 Object.defineProperty(exports, "IndexLoaderFactory", { enumerable: true, get: function () { return index_loader_1.IndexLoaderFactory; } });
 var query_loader_1 = require("./query_loader");
-Object.defineProperty(exports, "QueryLoader", { enumerable: true, get: function () { return query_loader_1.QueryLoader; } });
-Object.defineProperty(exports, "QueryDirectLoader", { enumerable: true, get: function () { return query_loader_1.QueryDirectLoader; } });
 Object.defineProperty(exports, "QueryLoaderFactory", { enumerable: true, get: function () { return query_loader_1.QueryLoaderFactory; } });

package/core/loaders/index_loader.d.ts

@@ -1,4 +1,4 @@
-import { ID, SelectBaseDataOptions, Context, Data, LoaderFactory, EdgeQueryableDataOptions } from "../base";
+import { ID, SelectBaseDataOptions, Context, Data, LoaderFactory, EdgeQueryableDataOptions, Loader } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
 export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
@@ -10,5 +10,5 @@ export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
         toPrime?: ObjectLoaderFactory<ID>[];
     });
     createLoader(context?: Context): any;
-    createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): import("../base").Loader<unknown, Data[]> | import("./query_loader").QueryDirectLoader<unknown>;
+    createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<ID, Data[]>;
 }

package/core/loaders/loader.js

@@ -37,12 +37,12 @@ class cacheMap {
             // might be a lot?
             // TODO this is not the best log format
             // was designed for ObjectLoader time. Now we have different needs e.g. count, assoc etc
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key,
                 "tableName": this.options.tableName,
             });
             // } else {
-            //   log("query", {
+            //   log("cache", {
             //     "dataloader-cache-miss": key,
             //     "tableName": options.tableName,
             //   });
@@ -50,21 +50,21 @@ class cacheMap {
         return ret;
     }
     set(key, value) {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-set": key,
         //   "tableName": options.tableName,
         // });
         return this.m.set(key, value);
     }
     delete(key) {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-delete": key,
         //   "tableName": options.tableName,
         // });
         return this.m.delete(key);
     }
     clear() {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-clear": true,
         //   "tableName": options.tableName,
         // });

package/core/loaders/object_loader.d.ts

@@ -1,18 +1,19 @@
-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[]>;
+    loadMany(keys: T[]): Promise<Array<Data | null>>;
     prime(data: Data): void;
+    primeAll(data: Data): void;
 }
 interface ObjectLoaderOptions extends SelectDataOptions {
     instanceKey?: string;
@@ -23,6 +24,6 @@ export declare class ObjectLoaderFactory<T> implements LoaderFactory<T, Data | n
     private toPrime;
     constructor(options: ObjectLoaderOptions);
     createLoader(context?: Context): ObjectLoader<T>;
-    addToPrime(factory: ObjectLoaderFactory<T>): void;
+    addToPrime(factory: ObjectLoaderFactory<T>): this;
 }
 export {};

package/core/loaders/object_loader.js

@@ -29,6 +29,47 @@ const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
+async function loadRowsForLoader(options, ids, context) {
+    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(cls, optionClause);
+        }
+    }
+    const rowOptions = {
+        ...options,
+        clause: cls,
+        context,
+    };
+    let m = new Map();
+    let result = [];
+    for (let i = 0; i < ids.length; i++) {
+        result.push(null);
+        // store the index....
+        m.set(ids[i], i);
+    }
+    const rows = await (0, ent_1.loadRows)(rowOptions);
+    for (const row of rows) {
+        const id = row[col];
+        if (id === undefined) {
+            throw new Error(`need to query for column ${col} when using an object loader because the query may not be sorted and we need the id to maintain sort order`);
+        }
+        const idx = m.get(id);
+        if (idx === undefined) {
+            throw new Error(`malformed query. got ${id} back but didn't query for it`);
+        }
+        result[idx] = row;
+    }
+    return result;
+}
 // 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...
@@ -42,42 +83,8 @@ function createDataLoader(options) {
         if (!ids.length) {
             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: cls,
-        };
-        let m = new Map();
-        let result = [];
-        for (let i = 0; i < ids.length; i++) {
-            result.push(null);
-            // store the index....
-            m.set(ids[i], i);
-        }
         // context not needed because we're creating a loader which has its own cache which is being used here
-        const rows = await (0, ent_1.loadRows)(rowOptions);
-        for (const row of rows) {
-            const id = row[col];
-            const idx = m.get(id);
-            if (idx === undefined) {
-                throw new Error(`malformed query. got ${id} back but didn't query for it`);
-            }
-            result[idx] = row;
-        }
-        return result;
+        return loadRowsForLoader(options, ids);
     }, loaderOptions);
 }
 class ObjectLoader {
@@ -136,7 +143,7 @@ class ObjectLoader {
                 optionClause = this.options.clause;
             }
             if (optionClause) {
-                cls = clause.And(optionClause, cls);
+                cls = clause.And(cls, optionClause);
             }
         }
         const rowOptions = {
@@ -144,7 +151,7 @@ class ObjectLoader {
             clause: cls,
             context: this.context,
         };
-        return await (0, ent_1.loadRow)(rowOptions);
+        return (0, ent_1.loadRow)(rowOptions);
     }
     clearAll() {
         this.loader && this.loader.clearAll();
@@ -153,25 +160,7 @@ 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: cls,
-            context: this.context,
-        };
-        return await (0, ent_1.loadRows)(rowOptions);
+        return loadRowsForLoader(this.options, keys, this.context);
     }
     prime(data) {
         // we have this data from somewhere else, prime it in the c
@@ -181,14 +170,28 @@ class ObjectLoader {
             this.loader.prime(key, data);
         }
     }
+    // prime this loader and any other loaders it's aware of
+    primeAll(data) {
+        this.prime(data);
+        if (this.primedLoaders) {
+            for (const [key, loader] of this.primedLoaders) {
+                const value = data[key];
+                if (value !== undefined) {
+                    loader.prime(data);
+                }
+            }
+        }
+    }
 }
 exports.ObjectLoader = ObjectLoader;
+// NOTE: if not querying for all columns
+// have to query for the id field as one of the fields
+// because it's used to maintain sort order of the queried ids
 class ObjectLoaderFactory {
     constructor(options) {
         this.options = options;
         this.toPrime = [];
-        // we don't wanna do it here because we want it to be delayed
-        let instanceKey = "";
+        let instanceKey = options.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`);
@@ -208,6 +211,7 @@ class ObjectLoaderFactory {
     // because there's usually self references here
     addToPrime(factory) {
         this.toPrime.push(factory);
+        return this;
     }
 }
 exports.ObjectLoaderFactory = ObjectLoaderFactory;

package/core/loaders/query_loader.d.ts

@@ -1,21 +1,14 @@
 import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
-export declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
+export declare function getOrderBy(sortCol: string, orderby?: string): string;
+declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     private options;
     private queryOptions?;
-    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
-    load(id: K): Promise<Data[]>;
-    clearAll(): void;
-}
-export declare class QueryLoader<K extends any> implements Loader<K, Data[]> {
-    private options;
-    context?: Context | undefined;
-    private queryOptions?;
-    private loader;
-    private primedLoaders;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private memoizedInitPrime;
-    constructor(options: QueryOptions, context?: Context | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
+    private primedLoaders;
+    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;
@@ -34,5 +27,6 @@ export declare class QueryLoaderFactory<K extends any> implements LoaderFactory<
     constructor(options: QueryOptions);
     createLoader(context?: Context): any;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<unknown, Data[]> | QueryDirectLoader<unknown>;
+    static createConfigurableLoader(name: string, queryOptions: QueryOptions, options: EdgeQueryableDataOptions, context?: Context): Loader<unknown, Data[]> | QueryDirectLoader<unknown>;
 }
 export {};

package/core/loaders/query_loader.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.QueryLoader = exports.QueryDirectLoader = void 0;
+exports.QueryLoaderFactory = exports.getOrderBy = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
@@ -30,13 +30,17 @@ const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
 function getOrderBy(sortCol, orderby) {
+    if (orderby) {
+        return orderby;
+    }
     let sortColLower = sortCol.toLowerCase();
     let orderbyDirection = " DESC";
     if (sortColLower.endsWith("asc") || sortCol.endsWith("desc")) {
         orderbyDirection = "";
     }
-    return orderby || `${sortCol}${orderbyDirection}`;
+    return `${sortCol}${orderbyDirection}`;
 }
+exports.getOrderBy = getOrderBy;
 async function simpleCase(options, id, queryOptions) {
     let cls;
     if (options.groupCol) {
@@ -120,16 +124,47 @@ function createLoader(options, queryOptions) {
     }, loaderOptions);
 }
 class QueryDirectLoader {
-    constructor(options, queryOptions) {
+    constructor(options, queryOptions, context) {
         this.options = options;
         this.queryOptions = queryOptions;
+        this.context = context;
+        this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
+    }
+    initPrime() {
+        if (!this.context || !this.options?.toPrime) {
+            return;
+        }
+        let primedLoaders = new Map();
+        this.options.toPrime.forEach((prime) => {
+            const l2 = prime.createLoader(this.context);
+            if (l2.prime === undefined) {
+                return;
+            }
+            primedLoaders.set(prime.options.key, l2);
+        });
+        this.primedLoaders = primedLoaders;
     }
     async load(id) {
-        return simpleCase(this.options, id, this.queryOptions);
+        const rows = await simpleCase(this.options, id, this.queryOptions);
+        if (this.context) {
+            this.memoizedInitPrime();
+            if (this.primedLoaders) {
+                for (const row of rows) {
+                    for (const [key, loader] of this.primedLoaders) {
+                        const value = row[key];
+                        if (value !== undefined) {
+                            loader.prime(row);
+                        }
+                    }
+                }
+            }
+        }
+        return rows;
     }
     clearAll() { }
 }
-exports.QueryDirectLoader = QueryDirectLoader;
+// note, you should never call this directly
+// there's scenarios where QueryDirectLoader is needed instead of this...
 class QueryLoader {
     constructor(options, context, queryOptions) {
         this.options = options;
@@ -176,7 +211,6 @@ class QueryLoader {
         this.loader && this.loader.clearAll();
     }
 }
-exports.QueryLoader = QueryLoader;
 class QueryLoaderFactory {
     constructor(options) {
         this.options = options;
@@ -194,11 +228,14 @@ class QueryLoaderFactory {
         return (0, loader_1.getLoader)(this, () => new QueryLoader(this.options, context), context);
     }
     createConfigurableLoader(options, context) {
-        if (options?.clause || !context) {
-            return new QueryDirectLoader(this.options, options);
+        return QueryLoaderFactory.createConfigurableLoader(this.name, this.options, options, context);
+    }
+    static createConfigurableLoader(name, queryOptions, options, context) {
+        if (options.clause || !context) {
+            return new QueryDirectLoader(queryOptions, options, context);
         }
-        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}`;
-        return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(this.options, context, options), context);
+        const key = `${name}:limit:${options.limit}:orderby:${options.orderby}`;
+        return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(queryOptions, context, options), context);
     }
 }
 exports.QueryLoaderFactory = QueryLoaderFactory;

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/logger.d.ts

@@ -1,4 +1,4 @@
-declare type logType = "query" | "warn" | "info" | "error" | "debug";
+declare type logType = "query" | "warn" | "info" | "error" | "debug" | "cache";
 export declare function setLogLevels(levels: logType | logType[]): void;
 export declare function clearLogLevels(): void;
 export declare function log(level: logType, msg: any): void;

package/core/logger.js

@@ -7,6 +7,7 @@ var m = {
     info: "log",
     error: "error",
     debug: "debug",
+    cache: "log",
 };
 var logLevels = new Map();
 function setLogLevels(levels) {

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;
@@ -183,6 +183,7 @@ export declare class AllowIfSubPolicyAllowsRule implements PrivacyPolicyRule {
 }
 export declare function applyPrivacyPolicy(v: Viewer, policy: PrivacyPolicy, ent: Ent | undefined): Promise<boolean>;
 export declare function applyPrivacyPolicyX(v: Viewer, policy: PrivacyPolicy, ent: Ent | undefined, throwErr?: () => Error): Promise<boolean>;
+export declare function applyPrivacyPolicyImpl(v: Viewer, policy: PrivacyPolicy, ent: Ent | undefined, throwErr?: () => Error): Promise<Error | null>;
 export declare const AlwaysAllowPrivacyPolicy: PrivacyPolicy;
 export declare const AlwaysDenyPrivacyPolicy: PrivacyPolicy;
 export declare const AllowIfViewerPrivacyPolicy: PrivacyPolicy;