@snowtop/ent 0.2.4 → 0.2.6

package/core/db.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresClient = exports.Postgres = exports.Sqlite = exports.defaultTimestampParser = exports.Dialect = void 0;
 const fs = __importStar(require("fs"));

package/core/ent.d.ts

@@ -19,6 +19,8 @@ declare class ErrorWrapper {
     constructor(error: Error);
 }
 export declare function rowIsError(row: any): row is Error;
+export declare function setEntLoaderPrivacyConcurrencyLimit(limit: number): void;
+export declare function getEntLoaderPrivacyConcurrencyLimit(): number;
 declare class EntLoader<TViewer extends Viewer, TEnt extends Ent<TViewer>> implements LoaderWithLoadMany<ID, TEnt | ErrorWrapper | Error> {
     private viewer;
     private options;

package/core/ent.js

@@ -15,19 +15,79 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadTwoWayEdges = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.getDefaultLimit = exports.setDefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.buildGroupQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = exports.getEntLoader = exports.rowIsError = void 0;
-exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = void 0;
+exports.assocEdgeLoader = exports.AssocEdgeData = exports.AssocEdge = void 0;
+exports.rowIsError = rowIsError;
+exports.setEntLoaderPrivacyConcurrencyLimit = setEntLoaderPrivacyConcurrencyLimit;
+exports.getEntLoaderPrivacyConcurrencyLimit = getEntLoaderPrivacyConcurrencyLimit;
+exports.getEntLoader = getEntLoader;
+exports.getEntKey = getEntKey;
+exports.loadEnt = loadEnt;
+exports.loadEntViaKey = loadEntViaKey;
+exports.loadEntX = loadEntX;
+exports.loadEntXViaKey = loadEntXViaKey;
+exports.loadEntFromClause = loadEntFromClause;
+exports.loadEntXFromClause = loadEntXFromClause;
+exports.loadEnts = loadEnts;
+exports.loadEntsList = loadEntsList;
+exports.loadEntsFromClause = loadEntsFromClause;
+exports.loadCustomEnts = loadCustomEnts;
+exports.loadCustomData = loadCustomData;
+exports.loadCustomCount = loadCustomCount;
+exports.loadDerivedEnt = loadDerivedEnt;
+exports.loadDerivedEntX = loadDerivedEntX;
+exports.logQuery = logQuery;
+exports.loadRowX = loadRowX;
+exports.loadRow = loadRow;
+exports.___setLogQueryErrorWithError = ___setLogQueryErrorWithError;
+exports.performRawQuery = performRawQuery;
+exports.loadRows = loadRows;
+exports.buildGroupQuery = buildGroupQuery;
+exports.buildInsertQuery = buildInsertQuery;
+exports.createRow = createRow;
+exports.createRowSync = createRowSync;
+exports.buildUpdateQuery = buildUpdateQuery;
+exports.editRow = editRow;
+exports.editRowSync = editRowSync;
+exports.deleteRows = deleteRows;
+exports.deleteRowsSync = deleteRowsSync;
+exports.getCursor = getCursor;
+exports.loadEdgeData = loadEdgeData;
+exports.loadEdgeDatas = loadEdgeDatas;
+exports.setDefaultLimit = setDefaultLimit;
+exports.getDefaultLimit = getDefaultLimit;
+exports.loadEdges = loadEdges;
+exports.getEdgeClauseAndFields = getEdgeClauseAndFields;
+exports.loadCustomEdges = loadCustomEdges;
+exports.loadUniqueEdge = loadUniqueEdge;
+exports.loadUniqueNode = loadUniqueNode;
+exports.loadRawEdgeCountX = loadRawEdgeCountX;
+exports.loadEdgeForID2 = loadEdgeForID2;
+exports.loadTwoWayEdges = loadTwoWayEdges;
+exports.loadNodesByEdge = loadNodesByEdge;
+exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
+exports.applyPrivacyPolicyForRows = applyPrivacyPolicyForRows;
+exports.getEdgeTypeInGroup = getEdgeTypeInGroup;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const dataloader_1 = __importDefault(require("dataloader"));
@@ -65,7 +125,9 @@ class entCacheMap {
     }
 }
 function createAssocEdgeConfigLoader(options) {
-    const loaderOptions = {};
+    const loaderOptions = {
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+    };
     // if query logging is enabled, we should log what's happening with loader
     if ((0, logger_1.logEnabled)("query")) {
         loaderOptions.cacheMap = new loader_1.CacheMap(options);
@@ -85,15 +147,14 @@ function createAssocEdgeConfigLoader(options) {
         // TODO is there a better way of doing this?
         // context not needed because we're creating a loader which has its own cache which is being used here
         const nodes = await loadRows(rowOptions);
-        let result = ids.map((id) => {
-            for (const node of nodes) {
-                if (node[col] === id) {
-                    return node;
-                }
+        const rowMap = new Map();
+        for (const node of nodes) {
+            const key = node[col];
+            if (!rowMap.has(key)) {
+                rowMap.set(key, node);
             }
-            return null;
-        });
-        return result;
+        }
+        return ids.map((id) => rowMap.get(id) ?? null);
     }, loaderOptions);
 }
 // used to wrap errors that would eventually be thrown in ents
@@ -109,53 +170,75 @@ function rowIsError(row) {
     // so we need to check the name as well for native error SqliteError
     return row instanceof Error || row?.constructor?.name === "SqliteError";
 }
-exports.rowIsError = rowIsError;
+let entLoaderPrivacyConcurrencyLimit = 20;
+function setEntLoaderPrivacyConcurrencyLimit(limit) {
+    entLoaderPrivacyConcurrencyLimit = limit;
+}
+function getEntLoaderPrivacyConcurrencyLimit() {
+    return entLoaderPrivacyConcurrencyLimit;
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    if (!items.length) {
+        return [];
+    }
+    const results = new Array(items.length);
+    const concurrency = limit === Infinity
+        ? items.length
+        : Number.isFinite(limit) && limit > 0
+            ? Math.floor(limit)
+            : 1;
+    let nextIndex = 0;
+    const workers = new Array(Math.min(concurrency, items.length))
+        .fill(null)
+        .map(async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            if (currentIndex >= items.length) {
+                return;
+            }
+            nextIndex += 1;
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
 function createEntLoader(viewer, options, map) {
     // share the cache across loaders even if we create a new instance
-    const loaderOptions = {};
+    const loaderOptions = {
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+    };
     loaderOptions.cacheMap = map;
     return new dataloader_1.default(async (ids) => {
         if (!ids.length) {
             return [];
         }
-        let result = [];
         const tableName = options.loaderFactory.options?.tableName;
         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];
+        return mapWithConcurrency(rows, getEntLoaderPrivacyConcurrencyLimit(), async (row, idx) => {
             // db error
             if (rowIsError(row)) {
                 if (row instanceof Error) {
-                    result[idx] = row;
-                }
-                else {
-                    // @ts-ignore SqliteError
-                    result[idx] = new Error(row.message);
+                    return row;
                 }
-                continue;
+                // @ts-ignore SqliteError
+                return new Error(row.message);
             }
-            else if (!row) {
+            if (!row) {
                 if (tableName) {
-                    result[idx] = new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]} in table ${tableName}`));
-                }
-                else {
-                    result[idx] = new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]}`));
+                    return new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]} in table ${tableName}`));
                 }
+                return new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]}`));
             }
-            else {
-                const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
-                if (rowIsError(r)) {
-                    result[idx] = new ErrorWrapper(r);
-                }
-                else {
-                    result[idx] = r;
-                }
+            const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+            if (rowIsError(r)) {
+                return new ErrorWrapper(r);
             }
-        }
-        return result;
+            return r;
+        });
     }, loaderOptions);
 }
 class EntLoader {
@@ -191,11 +274,9 @@ function getEntLoader(viewer, options) {
     const name = `ent-loader:${viewer.instanceKey()}:${options.loaderFactory.name}`;
     return viewer.context.cache.getLoaderWithLoadMany(name, () => new EntLoader(viewer, options));
 }
-exports.getEntLoader = getEntLoader;
 function getEntKey(viewer, id, options) {
     return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
 }
-exports.getEntKey = getEntKey;
 async function loadEnt(viewer, id, options) {
     if (typeof id !== "string" &&
         typeof id !== "number" &&
@@ -205,7 +286,6 @@ 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) {
@@ -243,7 +323,6 @@ async function loadEntViaKey(viewer, key, options) {
     const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options);
     return r instanceof ErrorWrapper ? null : r;
 }
-exports.loadEntViaKey = loadEntViaKey;
 async function loadEntX(viewer, id, options) {
     if (typeof id !== "string" &&
         typeof id !== "number" &&
@@ -256,7 +335,6 @@ async function loadEntX(viewer, id, options) {
     }
     return r;
 }
-exports.loadEntX = loadEntX;
 async function loadEntXViaKey(viewer, key, options) {
     const row = await options.loaderFactory
         .createLoader(viewer.context)
@@ -271,7 +349,6 @@ async function loadEntXViaKey(viewer, key, options) {
     }
     return r;
 }
-exports.loadEntXViaKey = loadEntXViaKey;
 /**
  * @deprecated use loadCustomEnts
  */
@@ -287,7 +364,6 @@ async function loadEntFromClause(viewer, options, clause) {
     }
     return applyPrivacyPolicyForRow(viewer, options, row);
 }
-exports.loadEntFromClause = loadEntFromClause;
 // same as loadEntFromClause
 // only works for ents where primary key is "id"
 // use loadEnt with a loaderFactory if different
@@ -303,7 +379,6 @@ async function loadEntXFromClause(viewer, options, clause) {
     const row = await loadRowX(rowOptions);
     return applyPrivacyPolicyForRowX(viewer, options, row);
 }
-exports.loadEntXFromClause = loadEntXFromClause;
 async function loadEnts(viewer, options, ...ids) {
     if (!ids.length) {
         return new Map();
@@ -322,7 +397,6 @@ async function loadEnts(viewer, options, ...ids) {
     }
     return m;
 }
-exports.loadEnts = loadEnts;
 // calls loadEnts and returns the results sorted in the order they were passed in
 // useful for EntQuery and other paths where the order matters
 async function loadEntsList(viewer, options, ...ids) {
@@ -336,7 +410,6 @@ async function loadEntsList(viewer, options, ...ids) {
     });
     return result;
 }
-exports.loadEntsList = loadEntsList;
 // we return a map here so that any sorting for queries that exist
 // can be done in O(N) time
 /**
@@ -351,12 +424,10 @@ async function loadEntsFromClause(viewer, clause, options) {
     const rows = await loadRows(rowOptions);
     return applyPrivacyPolicyForRowsDeprecated(viewer, rows, options);
 }
-exports.loadEntsFromClause = loadEntsFromClause;
 async function loadCustomEnts(viewer, options, query) {
     const rows = await loadCustomData(options, query, viewer.context);
     return applyPrivacyPolicyForRows(viewer, rows, options);
 }
-exports.loadCustomEnts = loadCustomEnts;
 function isClause(opts) {
     const cls = opts;
     return cls.clause !== undefined && cls.values !== undefined;
@@ -410,7 +481,6 @@ async function loadCustomData(options, query, context) {
     }
     return rows;
 }
-exports.loadCustomData = loadCustomData;
 // NOTE: if you use a raw query or paramterized query with this,
 // you should use `SELECT count(*) as count...`
 async function loadCustomCount(options, query, context) {
@@ -428,7 +498,6 @@ async function loadCustomCount(options, query, context) {
     }
     return 0;
 }
-exports.loadCustomCount = loadCustomCount;
 function isPrimableLoader(loader) {
     return loader != undefined;
 }
@@ -484,13 +553,11 @@ async function loadDerivedEnt(viewer, data, loader) {
     }
     return r;
 }
-exports.loadDerivedEnt = loadDerivedEnt;
 // won't have caching yet either
 async function loadDerivedEntX(viewer, data, loader) {
     const ent = new loader(viewer, data);
     return applyPrivacyPolicyForEntX(viewer, ent, data, { ent: loader });
 }
-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) {
@@ -551,7 +618,6 @@ function logQuery(query, logValues) {
     });
     (0, logger_1.logTrace)();
 }
-exports.logQuery = logQuery;
 // TODO long term figure out if this API should be exposed
 async function loadRowX(options) {
     const result = await loadRow(options);
@@ -562,7 +628,6 @@ async function loadRowX(options) {
     }
     return result;
 }
-exports.loadRowX = loadRowX;
 // primitive data fetching. called by loaders
 async function loadRow(options) {
     let cache = options.context?.cache;
@@ -588,12 +653,10 @@ async function loadRow(options) {
     }
     return res.rows[0];
 }
-exports.loadRow = loadRow;
 var _logQueryWithError = false;
 function ___setLogQueryErrorWithError(val) {
     _logQueryWithError = val || false;
 }
-exports.___setLogQueryErrorWithError = ___setLogQueryErrorWithError;
 // this always goes to the db, no cache, nothing
 async function performRawQuery(query, values, logValues) {
     const pool = db_1.default.getInstance().getPool();
@@ -610,7 +673,6 @@ async function performRawQuery(query, values, logValues) {
         throw e;
     }
 }
-exports.performRawQuery = performRawQuery;
 // TODO this should throw, we can't be hiding errors here
 async function loadRows(options) {
     let cache = options.context?.cache;
@@ -628,7 +690,6 @@ async function loadRows(options) {
     }
     return r;
 }
-exports.loadRows = loadRows;
 // this is used for queries when we select multiple ids at once
 function buildGroupQuery(options) {
     const fields = [...options.fields, "row_number()"];
@@ -658,7 +719,6 @@ function buildGroupQuery(options) {
         cls,
     ];
 }
-exports.buildGroupQuery = buildGroupQuery;
 function isSyncQueryer(queryer) {
     return queryer.execSync !== undefined;
 }
@@ -751,7 +811,6 @@ function buildInsertQuery(options, suffix) {
     }
     return [query, values, logValues];
 }
-exports.buildInsertQuery = buildInsertQuery;
 // TODO: these three are not to be exported out of this package
 // only from this file
 async function createRow(queryer, options, suffix) {
@@ -762,7 +821,6 @@ async function createRow(queryer, options, suffix) {
     }
     return null;
 }
-exports.createRow = createRow;
 function createRowSync(queryer, options, suffix) {
     const [query, values, logValues] = buildInsertQuery(options, suffix);
     const res = mutateRowSync(queryer, query, values, logValues, options);
@@ -771,7 +829,6 @@ function createRowSync(queryer, options, suffix) {
     }
     return null;
 }
-exports.createRowSync = createRowSync;
 function buildUpdateQuery(options, suffix) {
     let valsString = [];
     let values = [];
@@ -819,7 +876,6 @@ function buildUpdateQuery(options, suffix) {
     }
     return [query, values, logValues];
 }
-exports.buildUpdateQuery = buildUpdateQuery;
 async function editRow(queryer, options, suffix) {
     const [query, values, logValues] = buildUpdateQuery(options, suffix);
     const res = await mutateRow(queryer, query, values, logValues, options);
@@ -831,7 +887,6 @@ async function editRow(queryer, options, suffix) {
     }
     return null;
 }
-exports.editRow = editRow;
 function editRowSync(queryer, options, suffix) {
     const [query, values, logValues] = buildUpdateQuery(options, suffix);
     const res = mutateRowSync(queryer, query, values, logValues, options);
@@ -843,17 +898,14 @@ function editRowSync(queryer, options, suffix) {
     }
     return null;
 }
-exports.editRowSync = editRowSync;
 async function deleteRows(queryer, options, cls) {
     const query = `DELETE FROM ${options.tableName} WHERE ${cls.clause(1)}`;
     await mutateRow(queryer, query, cls.values(), cls.logValues(), options);
 }
-exports.deleteRows = deleteRows;
 function deleteRowsSync(queryer, options, cls) {
     const query = `DELETE FROM ${options.tableName} WHERE ${cls.clause(1)}`;
     mutateRowSync(queryer, query, cls.values(), cls.logValues(), options);
 }
-exports.deleteRowsSync = deleteRowsSync;
 class AssocEdge {
     constructor(data) {
         this.id1 = data.id1;
@@ -897,7 +949,6 @@ function getCursor(opts) {
     }
     return btoa(JSON.stringify(parts));
 }
-exports.getCursor = getCursor;
 class AssocEdgeData {
     constructor(data) {
         this.edgeType = data.edge_type;
@@ -930,7 +981,6 @@ async function loadEdgeData(edgeType) {
     }
     return new AssocEdgeData(row);
 }
-exports.loadEdgeData = loadEdgeData;
 async function loadEdgeDatas(...edgeTypes) {
     if (!edgeTypes.length) {
         return new Map();
@@ -948,7 +998,6 @@ async function loadEdgeDatas(...edgeTypes) {
     });
     return m;
 }
-exports.loadEdgeDatas = loadEdgeDatas;
 const edgeFields = [
     "id1",
     "id1_type",
@@ -962,11 +1011,9 @@ let defaultLimit = 1000;
 function setDefaultLimit(limit) {
     defaultLimit = limit;
 }
-exports.setDefaultLimit = setDefaultLimit;
 function getDefaultLimit() {
     return defaultLimit;
 }
-exports.getDefaultLimit = getDefaultLimit;
 function defaultEdgeQueryOptions(id1, edgeType, id2) {
     let cls = clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType));
     if (id2) {
@@ -986,7 +1033,6 @@ function defaultEdgeQueryOptions(id1, edgeType, id2) {
 async function loadEdges(options) {
     return loadCustomEdges({ ...options, ctr: AssocEdge });
 }
-exports.loadEdges = loadEdges;
 function getEdgeClauseAndFields(cls, options) {
     let fields = edgeFields;
     const transformEdgeRead = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeRead;
@@ -1002,7 +1048,6 @@ function getEdgeClauseAndFields(cls, options) {
         fields,
     };
 }
-exports.getEdgeClauseAndFields = getEdgeClauseAndFields;
 async function loadCustomEdges(options) {
     const { cls: actualClause, fields, defaultOptions, tableName, } = await loadEdgesInfo(options);
     const rows = await loadRows({
@@ -1017,7 +1062,6 @@ async function loadCustomEdges(options) {
         return new options.ctr(row);
     });
 }
-exports.loadCustomEdges = loadCustomEdges;
 async function loadEdgesInfo(options, id2) {
     const { id1, edgeType } = options;
     const edgeData = await loadEdgeData(edgeType);
@@ -1053,7 +1097,6 @@ async function loadUniqueEdge(options) {
     }
     return new AssocEdge(row);
 }
-exports.loadUniqueEdge = loadUniqueEdge;
 async function loadUniqueNode(viewer, id1, edgeType, options) {
     const edge = await loadUniqueEdge({
         id1,
@@ -1065,7 +1108,6 @@ async function loadUniqueNode(viewer, id1, edgeType, options) {
     }
     return loadEnt(viewer, edge.id2, options);
 }
-exports.loadUniqueNode = loadUniqueNode;
 async function loadRawEdgeCountX(options) {
     const { id1, edgeType, context } = options;
     const edgeData = await loadEdgeData(edgeType);
@@ -1082,7 +1124,6 @@ async function loadRawEdgeCountX(options) {
     });
     return parseInt(row["count"], 10) || 0;
 }
-exports.loadRawEdgeCountX = loadRawEdgeCountX;
 async function loadEdgeForID2(options) {
     const { cls: actualClause, fields, tableName, } = await loadEdgesInfo(options, options.id2);
     const row = await loadRow({
@@ -1095,7 +1136,6 @@ async function loadEdgeForID2(options) {
         return new options.ctr(row);
     }
 }
-exports.loadEdgeForID2 = loadEdgeForID2;
 async function loadTwoWayEdges(opts) {
     const { cls: actualClause, fields, tableName } = await loadEdgesInfo(opts);
     const rows = await loadRows({
@@ -1116,7 +1156,6 @@ async function loadTwoWayEdges(opts) {
     });
     return rows;
 }
-exports.loadTwoWayEdges = loadTwoWayEdges;
 async function loadNodesByEdge(viewer, id1, edgeType, options) {
     // load edges
     const rows = await loadEdges({
@@ -1128,12 +1167,10 @@ async function loadNodesByEdge(viewer, id1, edgeType, options) {
     const ids = rows.map((row) => row.id2);
     return loadEntsList(viewer, options, ...ids);
 }
-exports.loadNodesByEdge = loadNodesByEdge;
 async function applyPrivacyPolicyForRow(viewer, options, row) {
     const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
     return rowIsError(r) ? null : r;
 }
-exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
 async function applyPrivacyPolicyForRowImpl(viewer, options, row) {
     const ent = new options.ent(viewer, row);
     return applyPrivacyPolicyForEnt(viewer, ent, row, options);
@@ -1170,7 +1207,6 @@ async function applyPrivacyPolicyForRows(viewer, rows, options) {
     // filter ents that aren't visible because of privacy
     return result.filter((r) => r !== undefined);
 }
-exports.applyPrivacyPolicyForRows = applyPrivacyPolicyForRows;
 // given a viewer, an id pair, and a map of edgeEnum to EdgeType
 // return the edgeEnum that's set in the group
 async function getEdgeTypeInGroup(viewer, id1, id2, m) {
@@ -1214,4 +1250,3 @@ async function getEdgeTypeInGroup(viewer, id1, id2, m) {
         }
     }
 }
-exports.getEdgeTypeInGroup = getEdgeTypeInGroup;

package/core/global_schema.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__getGlobalSchemaField = exports.__getGlobalSchemaFields = exports.__getGlobalSchema = exports.__hasGlobalSchema = exports.clearGlobalSchema = exports.setGlobalSchema = void 0;
+exports.setGlobalSchema = setGlobalSchema;
+exports.clearGlobalSchema = clearGlobalSchema;
+exports.__hasGlobalSchema = __hasGlobalSchema;
+exports.__getGlobalSchema = __getGlobalSchema;
+exports.__getGlobalSchemaFields = __getGlobalSchemaFields;
+exports.__getGlobalSchemaField = __getGlobalSchemaField;
 const schema_1 = require("../schema/schema");
 let globalSchema;
 let globalSchemaFields = new Map();
@@ -25,27 +30,21 @@ function setGlobalSchema(val) {
         }
     }
 }
-exports.setGlobalSchema = setGlobalSchema;
 function clearGlobalSchema() {
     globalSchema = undefined;
     globalSchemaFields.clear();
 }
-exports.clearGlobalSchema = clearGlobalSchema;
 // used by tests. no guarantee will always exist
 function __hasGlobalSchema() {
     return globalSchema !== undefined;
 }
-exports.__hasGlobalSchema = __hasGlobalSchema;
 // used by tests. no guarantee will always exist
 function __getGlobalSchema() {
     return globalSchema;
 }
-exports.__getGlobalSchema = __getGlobalSchema;
 function __getGlobalSchemaFields() {
     return globalSchemaFields;
 }
-exports.__getGlobalSchemaFields = __getGlobalSchemaFields;
 function __getGlobalSchemaField(type) {
     return globalSchemaFields.get(type);
 }
-exports.__getGlobalSchemaField = __getGlobalSchemaField;

package/core/loaders/assoc_count_loader.d.ts

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