@snowtop/ent 0.1.0-alpha85 → 0.1.0-alpha86

package/core/base.d.ts

@@ -5,12 +5,12 @@ export interface Loader<T, V> {
     loadMany?(keys: T[]): Promise<(V | null)[]>;
     clearAll(): any;
 }
-interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
-    loadMany(keys: T[]): Promise<(V | null)[]>;
+export interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
+    loadMany(keys: T[]): Promise<V[]>;
 }
-export interface LoaderFactory<T, V> {
+export interface LoaderFactory<K, V> {
     name: string;
-    createLoader(context?: Context): Loader<T, V>;
+    createLoader(context?: Context): Loader<K, V>;
 }
 interface LoaderFactoryWithLoaderMany<T, V> extends LoaderFactory<T, V> {
     createLoader(context?: Context): LoaderWithLoadMany<T, V>;
@@ -25,12 +25,12 @@ export interface PrimableLoader<T, V> extends Loader<T, V> {
 }
 interface cache {
     getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
+    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
     getCachedRows(options: queryOptions): Data[] | null;
     getCachedRow(options: queryOptions): Data | null;
     primeCache(options: queryOptions, rows: Data[]): void;
     primeCache(options: queryOptions, rows: Data): void;
     clearCache(): void;
-    getEntCache(): Map<string, Ent | Error | null>;
 }
 interface queryOptions {
     fields: string[];

package/core/context.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Viewer, Data, Loader, Ent } from "./base";
+import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
@@ -11,17 +11,17 @@ export interface RequestContext<TViewer extends Viewer = Viewer> extends Context
 }
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
+    loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
     getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
+    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
     private itemMap;
     private listMap;
-    private entCache;
     private getkey;
     getCachedRows(options: queryOptions): Data[] | null;
     getCachedRow(options: queryOptions): Data | null;
     primeCache(options: queryOptions, rows: Data[]): void;
     primeCache(options: queryOptions, rows: Data): void;
     clearCache(): void;
-    getEntCache(): Map<string, Error | Ent<any> | null>;
 }
 interface queryOptions {
     fields: string[];

package/core/context.js

@@ -5,10 +5,11 @@ const logger_1 = require("./logger");
 class ContextCache {
     constructor() {
         this.loaders = new Map();
+        // we should eventually combine the two but better for typing to be separate for now
+        this.loaderWithLoadMany = new Map();
         // we have a per-table map to make it easier to purge and have less things to compare with
         this.itemMap = new Map();
         this.listMap = new Map();
-        this.entCache = new Map();
     }
     getLoader(name, create) {
         let l = this.loaders.get(name);
@@ -20,6 +21,16 @@ class ContextCache {
         this.loaders.set(name, l);
         return l;
     }
+    getLoaderWithLoadMany(name, create) {
+        let l = this.loaderWithLoadMany.get(name);
+        if (l) {
+            return l;
+        }
+        (0, logger_1.log)("debug", `new context-aware loader created for ${name}`);
+        l = create();
+        this.loaderWithLoadMany.set(name, l);
+        return l;
+    }
     // tableName is ignored bcos already indexed on that
     // maybe we just want to store sql queries???
     getkey(options) {
@@ -80,13 +91,15 @@ class ContextCache {
             // but may have some benefits by explicitily doing so?
             loader.clearAll();
         }
+        for (const [_key, loader] of this.loaderWithLoadMany) {
+            // may not need this since we're clearing the loaders themselves...
+            // but may have some benefits by explicitily doing so?
+            loader.clearAll();
+        }
         this.loaders.clear();
+        this.loaderWithLoadMany.clear();
         this.itemMap.clear();
         this.listMap.clear();
-        this.entCache.clear();
-    }
-    getEntCache() {
-        return this.entCache;
     }
 }
 exports.ContextCache = ContextCache;

package/core/ent.d.ts

@@ -225,7 +225,7 @@ interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptio
 }
 export declare function loadEdgeForID2<T extends AssocEdge>(options: loadEdgeForIDOptions<T>): Promise<T | undefined>;
 export declare function loadNodesByEdge<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T[]>;
-export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data | null): Promise<TEnt | null>;
+export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data): Promise<TEnt | null>;
 export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
 export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
 export {};

package/core/ent.js

@@ -57,6 +57,34 @@ class cacheMap {
         return this.m.clear();
     }
 }
+class entCacheMap {
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = options;
+        this.m = new Map();
+        this.logEnabled = false;
+        this.logEnabled = (0, logger_1.logEnabled)("cache");
+    }
+    get(id) {
+        const ret = this.m.get(id);
+        if (this.logEnabled && ret) {
+            const key = getEntKey(this.viewer, id, this.options);
+            (0, logger_1.log)("cache", {
+                "ent-cache-hit": key,
+            });
+        }
+        return ret;
+    }
+    set(key, value) {
+        return this.m.set(key, value);
+    }
+    delete(key) {
+        return this.m.delete(key);
+    }
+    clear() {
+        return this.m.clear();
+    }
+}
 function createDataLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
@@ -87,60 +115,116 @@ function createDataLoader(options) {
         return result;
     }, loaderOptions);
 }
-function getEntKey(viewer, id, options) {
-    return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
-}
-exports.getEntKey = getEntKey;
-// fetches the ent from cache if cache exists.
-function entFromCacheMaybe(viewer, id, options) {
-    const cache = viewer.context?.cache?.getEntCache();
-    if (!cache) {
-        return {};
-    }
-    const key = getEntKey(viewer, id, options);
-    const r = cache.get(key);
-    if (r !== undefined) {
-        (0, logger_1.log)("cache", {
-            "ent-cache-hit": key,
-        });
+// used to wrap errors that would eventually be thrown in ents
+// not an Error because DataLoader automatically rejects that
+class ErrorWrapper {
+    constructor(error) {
+        this.error = error;
     }
-    return {
-        key,
-        ent: r instanceof Error ? undefined : r,
-        error: r instanceof Error ? r : undefined,
-        cache,
-    };
 }
-// Ent accessors
-async function applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info) {
-    const ent = await applyPrivacyPolicyForRow(viewer, options, row);
-    if (info.cache && info.key) {
-        info.cache.set(info.key, ent);
-    }
-    return ent instanceof Error ? null : ent;
+function createEntLoader(viewer, options, map) {
+    // share the cache across loaders even if we create a new instance
+    const loaderOptions = {};
+    loaderOptions.cacheMap = map;
+    return new dataloader_1.default(async (ids) => {
+        if (!ids.length) {
+            return [];
+        }
+        let result = [];
+        const loader = options.loaderFactory.createLoader(viewer.context);
+        const rows = await loader.loadMany(ids);
+        // this is a loader which should return the same order based on passed-in ids
+        // so let's depend on that...
+        for (let idx = 0; idx < rows.length; idx++) {
+            const row = rows[idx];
+            // db error
+            if (row instanceof Error) {
+                result[idx] = row;
+                continue;
+            }
+            else if (!row) {
+                result[idx] = new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]}`));
+            }
+            else {
+                const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+                if (r instanceof Error) {
+                    result[idx] = new ErrorWrapper(r);
+                }
+                else {
+                    result[idx] = r;
+                }
+            }
+        }
+        return result;
+    }, loaderOptions);
 }
-async function applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info) {
-    const ent = await applyPrivacyPolicyForRowImpl(viewer, options, row);
-    if (info.cache && info.key) {
-        info.cache.set(info.key, ent);
+class EntLoader {
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = options;
+        this.map = new entCacheMap(viewer, options);
+        this.loader = createEntLoader(this.viewer, this.options, this.map);
     }
-    if (ent instanceof Error) {
-        throw ent;
+    getMap() {
+        return this.map;
     }
-    if (ent === null) {
-        throw new Error(`applyPrivacyPolicyForRowImpl returned null when it shouldn't. ent error`);
+    async load(id) {
+        return this.loader.load(id);
+    }
+    async loadMany(ids) {
+        return this.loader.loadMany(ids);
+    }
+    prime(id, ent) {
+        this.loader.prime(id, ent);
+    }
+    clear(id) {
+        this.loader.clear(id);
+    }
+    clearAll() {
+        this.loader.clearAll();
     }
-    return ent;
 }
-async function loadEnt(viewer, id, options) {
-    const info = entFromCacheMaybe(viewer, id, options);
-    if (info.ent !== undefined) {
-        return info.ent;
+function getEntLoader(viewer, options) {
+    if (!viewer.context?.cache) {
+        return new EntLoader(viewer, options);
     }
-    const row = await options.loaderFactory.createLoader(viewer.context).load(id);
-    return applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
+    const name = `ent-loader:${viewer.instanceKey()}:${options.loaderFactory.name}`;
+    return viewer.context.cache.getLoaderWithLoadMany(name, () => new EntLoader(viewer, options));
+}
+function getEntKey(viewer, id, options) {
+    return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
+}
+exports.getEntKey = getEntKey;
+async function loadEnt(viewer, id, options) {
+    const r = await getEntLoader(viewer, options).load(id);
+    return r instanceof ErrorWrapper ? null : r;
 }
 exports.loadEnt = loadEnt;
+async function applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, 
+// can pass in loader when calling this for multi-id cases...
+loader) {
+    if (!loader) {
+        loader = getEntLoader(viewer, options);
+    }
+    // TODO every row.id needs to be audited...
+    // https://github.com/lolopinto/ent/issues/1064
+    const id = row.id;
+    // we should check the ent loader cache to see if this is already there
+    // TODO hmm... we eventually need a custom data-loader for this too so that it's all done correctly if there's a complicated fetch deep down in graphql
+    const result = loader.getMap().get(id);
+    if (result !== undefined) {
+        return result;
+    }
+    const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+    if (r instanceof Error) {
+        loader.prime(id, new ErrorWrapper(r));
+        return new ErrorWrapper(r);
+    }
+    else {
+        loader.prime(id, r);
+        return r;
+    }
+}
 // this is the same implementation-wise (right now) as loadEnt. it's just clearer that it's not loaded via ID.
 // used for load via email address etc
 async function loadEntViaKey(viewer, key, options) {
@@ -150,29 +234,16 @@ async function loadEntViaKey(viewer, key, options) {
     if (!row) {
         return null;
     }
-    // TODO every row.id needs to be audited...
-    // https://github.com/lolopinto/ent/issues/1064
-    const info = entFromCacheMaybe(viewer, row.id, options);
-    if (info.ent !== undefined) {
-        return info.ent;
-    }
-    return applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
+    const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options);
+    return r instanceof ErrorWrapper ? null : r;
 }
 exports.loadEntViaKey = loadEntViaKey;
 async function loadEntX(viewer, id, options) {
-    const info = entFromCacheMaybe(viewer, id, options);
-    if (info.error !== undefined) {
-        throw info.error;
+    const r = await getEntLoader(viewer, options).load(id);
+    if (r instanceof ErrorWrapper) {
+        throw r.error;
     }
-    if (info.ent !== undefined && info.ent !== null) {
-        return info.ent;
-    }
-    const row = await options.loaderFactory.createLoader(viewer.context).load(id);
-    if (!row) {
-        // todo make this better
-        throw new Error(`${options.loaderFactory.name}: couldn't find row for value ${id}`);
-    }
-    return applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info);
+    return r;
 }
 exports.loadEntX = loadEntX;
 async function loadEntXViaKey(viewer, key, options) {
@@ -183,14 +254,14 @@ async function loadEntXViaKey(viewer, key, options) {
         // todo make this better
         throw new Error(`${options.loaderFactory.name}: couldn't find row for value ${key}`);
     }
-    const info = entFromCacheMaybe(viewer, row.id, options);
-    if (info.error !== undefined) {
-        throw info.error;
-    }
-    if (info.ent !== undefined && info.ent !== null) {
-        return info.ent;
+    // this should have primed the other cache so there isn't a database query
+    // TODO every row.id needs to be audited...
+    // https://github.com/lolopinto/ent/issues/1064
+    const r = await getEntLoader(viewer, options).load(row.id);
+    if (r instanceof ErrorWrapper) {
+        throw r.error;
     }
-    return applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info);
+    return r;
 }
 exports.loadEntXViaKey = loadEntXViaKey;
 /**
@@ -203,6 +274,9 @@ async function loadEntFromClause(viewer, options, clause) {
         context: viewer.context,
     };
     const row = await loadRow(rowOptions);
+    if (row === null) {
+        return null;
+    }
     return applyPrivacyPolicyForRow(viewer, options, row);
 }
 exports.loadEntFromClause = loadEntFromClause;
@@ -228,62 +302,15 @@ async function loadEnts(viewer, options, ...ids) {
     }
     // result
     let m = new Map();
-    const cache = viewer.context?.cache?.getEntCache();
-    let toFetch = [];
-    if (cache) {
-        for (const id of ids) {
-            const key = getEntKey(viewer, id, options);
-            const ent = cache.get(key);
-            if (ent !== undefined) {
-                (0, logger_1.log)("cache", {
-                    "ent-cache-hit": key,
-                });
-                if (ent === null) {
-                    // TODO this should return null if not loadable...
-                    // https://github.com/lolopinto/ent/issues/1070
-                    continue;
-                }
-                // @ts-ignore
-                m.set(id, ent);
-            }
-            else {
-                toFetch.push(id);
-            }
+    const ret = await getEntLoader(viewer, options).loadMany(ids);
+    for (const r of ret) {
+        if (r instanceof Error) {
+            throw r;
         }
-    }
-    else {
-        toFetch = ids;
-    }
-    // all in ent cache!
-    if (!toFetch.length) {
-        return m;
-    }
-    const l = options.loaderFactory.createLoader(viewer.context);
-    const rows = await l.loadMany(toFetch);
-    let rows2 = [];
-    for (const row of rows) {
-        if (!row) {
+        if (r instanceof ErrorWrapper) {
             continue;
         }
-        if (row instanceof Error) {
-            throw row;
-        }
-        rows2.push(row);
-    }
-    const m2 = await applyPrivacyPolicyForRows(viewer, rows2, options);
-    for (const row of rows2) {
-        const id = row[options.loaderFactory.options?.key || "id"];
-        const ent = m2.get(id);
-        if (cache) {
-            // put back in cache...
-            // store null for rows that can't be seen
-            cache.set(getEntKey(viewer, id, options), ent ?? null);
-        }
-        if (ent !== undefined) {
-            // TODO this should return null if not loadable...?
-            // TODO https://github.com/lolopinto/ent/issues/1070
-            m.set(id, ent);
-        }
+        m.set(r.id, r);
     }
     return m;
 }
@@ -320,23 +347,16 @@ exports.loadEntsFromClause = loadEntsFromClause;
 async function loadCustomEnts(viewer, options, query) {
     const rows = await loadCustomData(options, query, viewer.context);
     const result = new Array(rows.length);
+    if (!rows.length) {
+        return [];
+    }
+    const entLoader = getEntLoader(viewer, options);
     await Promise.all(rows.map(async (row, idx) => {
-        // TODO what if key is different
-        // TODO https://github.com/lolopinto/ent/issues/1064
-        const info = entFromCacheMaybe(viewer, row.id, options);
-        if (info.ent !== undefined) {
-            if (info.ent === null) {
-                // we're done here
-                return;
-            }
-            // @ts-ignore
-            result[idx] = info.ent;
+        const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, entLoader);
+        if (r instanceof ErrorWrapper) {
             return;
         }
-        const privacyEnt = await applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
-        if (privacyEnt) {
-            result[idx] = privacyEnt;
-        }
+        result[idx] = r;
     }));
     // filter ents that aren't visible because of privacy
     return result.filter((r) => r !== undefined);
@@ -457,14 +477,11 @@ exports.loadDerivedEntX = loadDerivedEntX;
 // 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 error = await (0, privacy_1.applyPrivacyPolicyImpl)(viewer, ent.getPrivacyPolicy(), ent);
-        if (error === null) {
-            return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
-        }
-        return error;
+    const error = await (0, privacy_1.applyPrivacyPolicyImpl)(viewer, ent.getPrivacyPolicy(), ent);
+    if (error === null) {
+        return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
     }
-    return null;
+    return error;
 }
 async function applyPrivacyPolicyForEntX(viewer, ent, data, options) {
     const r = await applyPrivacyPolicyForEnt(viewer, ent, data, options);
@@ -1505,9 +1522,6 @@ async function applyPrivacyPolicyForRow(viewer, options, row) {
 }
 exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
 async function applyPrivacyPolicyForRowImpl(viewer, options, row) {
-    if (!row) {
-        return null;
-    }
     const ent = new options.ent(viewer, row);
     return applyPrivacyPolicyForEnt(viewer, ent, row, options);
 }

package/core/loaders/object_loader.d.ts

@@ -11,7 +11,7 @@ export declare class ObjectLoader<T> implements Loader<T, Data | null> {
     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;
 }
@@ -24,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,45 +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(cls, optionClause);
-            }
-        }
-        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];
-            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;
+        return loadRowsForLoader(options, ids);
     }, loaderOptions);
 }
 class ObjectLoader {
@@ -147,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();
@@ -156,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(cls, optionClause);
-            }
-        }
-        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
@@ -225,6 +211,7 @@ class ObjectLoaderFactory {
     // because there's usually self references here
     addToPrime(factory) {
         this.toPrime.push(factory);
+        return this;
     }
 }
 exports.ObjectLoaderFactory = ObjectLoaderFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha85",
+  "version": "0.1.0-alpha86",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",