@snowtop/ent 0.2.6 → 0.2.7

package/core/async_utils.d.ts

@@ -0,0 +1 @@
+export declare function mapWithConcurrency<T, U>(items: T[], limit: number, mapper: (item: T, index: number) => Promise<U>): Promise<U[]>;

package/core/async_utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapWithConcurrency = mapWithConcurrency;
+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.max(1, 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;
+}

package/core/base.d.ts

@@ -26,7 +26,7 @@ export interface PrimableLoader<K, V> extends Loader<K, V> {
     prime(d: V): void;
     primeAll?(d: V): void;
 }
-export type QueryOptions = Required<Pick<LoadRowsOptions, "clause" | "fields" | "tableName">> & Pick<LoadRowsOptions, "orderby" | "join">;
+export type QueryOptions = Required<Pick<LoadRowsOptions, "clause" | "fields" | "tableName">> & Pick<LoadRowsOptions, "distinct" | "alias" | "fieldsAlias" | "disableFieldsAlias" | "disableDefaultOrderByAlias" | "groupby" | "orderby" | "join" | "limit" | "offset">;
 interface cache {
     getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
     getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;

package/core/config.d.ts

@@ -20,6 +20,8 @@ export interface Config {
     logQueryWithError?: boolean;
     defaultConnectionLimit?: number;
     loaderMaxBatchSize?: number;
+    clauseLoaderConcurrency?: number;
+    entLoaderPrivacyConcurrencyLimit?: number;
 }
 export interface ConfigWithCodegen extends Config {
     codegen?: CodegenConfig;

package/core/config.js

@@ -43,6 +43,7 @@ const db_1 = __importDefault(require("./db"));
 const path = __importStar(require("path"));
 const logger_1 = require("./logger");
 const ent_1 = require("./ent");
+const object_loader_1 = require("./loaders/object_loader");
 const loader_1 = require("./loaders/loader");
 // ent.config.ts eventually. for now ent.yml
 // or ent.yml?
@@ -79,6 +80,12 @@ function setConfig(cfg) {
     if (cfg.loaderMaxBatchSize !== undefined) {
         (0, loader_1.setLoaderMaxBatchSize)(cfg.loaderMaxBatchSize);
     }
+    if (cfg.clauseLoaderConcurrency !== undefined) {
+        (0, object_loader_1.setClauseLoaderConcurrency)(cfg.clauseLoaderConcurrency);
+    }
+    if (cfg.entLoaderPrivacyConcurrencyLimit !== undefined) {
+        (0, ent_1.setEntLoaderPrivacyConcurrencyLimit)(cfg.entLoaderPrivacyConcurrencyLimit);
+    }
 }
 function isBuffer(b) {
     return b.write !== undefined;

package/core/context.d.ts

@@ -1,12 +1,15 @@
 import { IncomingMessage, ServerResponse } from "http";
 import { Data, Loader, LoaderWithLoadMany, QueryOptions, Viewer } from "./base";
 import { Context } from "./base";
+export declare function getContextCacheMaxDiscardedLoaders(): number;
+export declare function setContextCacheMaxDiscardedLoaders(size?: number | null): void;
 export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
     authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
     request: IncomingMessage;
     response: ServerResponse;
 }
+export declare function getContextCacheKey(options: QueryOptions): string;
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
     loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
@@ -15,7 +18,6 @@ export declare class ContextCache {
     getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     private itemMap;
     private listMap;
-    private getkey;
     getCachedRows(options: QueryOptions): Data[] | null;
     getCachedRow(options: QueryOptions): Data | null;
     primeCache(options: QueryOptions, rows: Data[]): void;

package/core/context.js

@@ -1,8 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextCache = void 0;
+exports.getContextCacheMaxDiscardedLoaders = getContextCacheMaxDiscardedLoaders;
+exports.setContextCacheMaxDiscardedLoaders = setContextCacheMaxDiscardedLoaders;
+exports.getContextCacheKey = getContextCacheKey;
 const logger_1 = require("./logger");
-const query_impl_1 = require("./query_impl");
+const cache_utils_1 = require("./cache_utils");
+const metrics_1 = require("./metrics");
+const DEFAULT_MAX_DISCARDED_LOADERS = 1000;
+let maxDiscardedLoaders = DEFAULT_MAX_DISCARDED_LOADERS;
+function getContextCacheMaxDiscardedLoaders() {
+    return maxDiscardedLoaders;
+}
+function setContextCacheMaxDiscardedLoaders(size) {
+    if (size === undefined || size === null) {
+        maxDiscardedLoaders = DEFAULT_MAX_DISCARDED_LOADERS;
+        return;
+    }
+    if (!Number.isFinite(size) || size < 0) {
+        throw new Error(`maxDiscardedLoaders must be a non-negative number`);
+    }
+    maxDiscardedLoaders = Math.floor(size);
+}
+function getContextCacheKey(options) {
+    const fields = options.fields
+        .map((f) => {
+        if (typeof f === "object") {
+            return `${f.alias}.${f.column}`;
+        }
+        return f;
+    })
+        .join(",");
+    const parts = [
+        `fields:${fields}`,
+        `clause:${options.clause.instanceKey()}`,
+    ];
+    if (options.distinct !== undefined) {
+        parts.push(`distinct:${options.distinct}`);
+    }
+    if (options.alias !== undefined) {
+        parts.push(`alias:${options.alias}`);
+    }
+    if (options.fieldsAlias !== undefined) {
+        parts.push(`fieldsAlias:${options.fieldsAlias}`);
+    }
+    if (options.disableFieldsAlias !== undefined) {
+        parts.push(`disableFieldsAlias:${options.disableFieldsAlias}`);
+    }
+    if (options.disableDefaultOrderByAlias !== undefined) {
+        parts.push(`disableDefaultOrderByAlias:${options.disableDefaultOrderByAlias}`);
+    }
+    if (options.groupby !== undefined) {
+        parts.push(`groupby:${options.groupby}`);
+    }
+    if (options.orderby) {
+        parts.push(`orderby:${(0, cache_utils_1.stableStringify)(options.orderby)}`);
+    }
+    if (options.join) {
+        const joinKey = options.join.map((join) => ({
+            type: join.type ?? "inner",
+            tableName: join.tableName,
+            alias: join.alias,
+            clause: join.clause.instanceKey(),
+        }));
+        parts.push(`join:${(0, cache_utils_1.stableStringify)(joinKey)}`);
+    }
+    if (options.limit !== undefined) {
+        parts.push(`limit:${options.limit}`);
+    }
+    if (options.offset !== undefined) {
+        parts.push(`offset:${options.offset}`);
+    }
+    return parts.join(",");
+}
 class ContextCache {
     constructor() {
         this.loaders = new Map();
@@ -37,34 +107,21 @@ class ContextCache {
     }
     // tableName is ignored bcos already indexed on that
     // maybe we just want to store sql queries???
-    getkey(options) {
-        let parts = [
-            options.fields
-                .map((f) => {
-                if (typeof f === "object") {
-                    return `${f.alias}.${f.column}`;
-                }
-                return f;
-            })
-                .join(","),
-            options.clause.instanceKey(),
-        ];
-        if (options.orderby) {
-            parts.push((0, query_impl_1.getOrderByPhrase)(options.orderby));
-        }
-        if (options.join) {
-            parts.push((0, query_impl_1.getJoinInfo)(options.join).phrase);
-        }
-        return parts.join(",");
-    }
     getCachedRows(options) {
         let m = this.listMap.get(options.tableName);
         if (!m) {
             return null;
         }
-        const key = this.getkey(options);
+        const key = getContextCacheKey(options);
         let rows = m.get(key);
         if (rows) {
+            const hook = (0, metrics_1.getOnQueryCacheHit)();
+            if (hook) {
+                hook({
+                    tableName: options.tableName,
+                    key,
+                });
+            }
             (0, logger_1.log)("cache", {
                 "cache-hit": key,
                 "tableName": options.tableName,
@@ -77,9 +134,16 @@ class ContextCache {
         if (!m) {
             return null;
         }
-        const key = this.getkey(options);
+        const key = getContextCacheKey(options);
         let row = m.get(key);
         if (row) {
+            const hook = (0, metrics_1.getOnQueryCacheHit)();
+            if (hook) {
+                hook({
+                    tableName: options.tableName,
+                    key,
+                });
+            }
             (0, logger_1.log)("cache", {
                 "cache-hit": key,
                 "tableName": options.tableName,
@@ -90,12 +154,12 @@ class ContextCache {
     primeCache(options, rows) {
         if (Array.isArray(rows)) {
             let m = this.listMap.get(options.tableName) || new Map();
-            m.set(this.getkey(options), rows);
+            m.set(getContextCacheKey(options), rows);
             this.listMap.set(options.tableName, m);
         }
         else {
             let m = this.itemMap.get(options.tableName) || new Map();
-            m.set(this.getkey(options), rows);
+            m.set(getContextCacheKey(options), rows);
             this.itemMap.set(options.tableName, m);
         }
     }
@@ -113,6 +177,13 @@ class ContextCache {
         this.loaderWithLoadMany.clear();
         this.itemMap.clear();
         this.listMap.clear();
+        if (maxDiscardedLoaders === 0) {
+            this.discardedLoaders = [];
+            return;
+        }
+        if (this.discardedLoaders.length > maxDiscardedLoaders) {
+            this.discardedLoaders = this.discardedLoaders.slice(-maxDiscardedLoaders);
+        }
     }
     /**
      * reset clears the cache and resets the discarded loaders

package/core/ent.d.ts

@@ -1,7 +1,7 @@
 import { Context, CreateRowOptions, Data, DataOptions, EdgeQueryableDataOptions, EditRowOptions, Ent, ID, LoadCustomEntOptions, LoadEntOptions, LoadRowOptions, LoadRowsOptions, LoaderWithLoadMany, QueryDataOptions, SelectCustomDataOptions, Viewer } from "./base";
 import { Queryer, SyncQueryer } from "./db";
-import DataLoader from "dataloader";
 import * as clause from "./clause";
+import { InstrumentedDataLoader } from "./loaders/loader";
 import { OrderBy } from "./query_impl";
 declare class entCacheMap<TViewer extends Viewer, TEnt extends Ent<TViewer>> {
     private viewer;
@@ -160,7 +160,7 @@ export declare class AssocEdgeData {
     edgeTable: string;
     constructor(data: Data);
 }
-export declare const assocEdgeLoader: DataLoader<ID, Data | null, ID>;
+export declare const assocEdgeLoader: InstrumentedDataLoader<ID, Data | null>;
 export declare function loadEdgeData(edgeType: string): Promise<AssocEdgeData | null>;
 export declare function loadEdgeDatas(...edgeTypes: string[]): Promise<Map<string, AssocEdgeData>>;
 export interface AssocEdgeConstructor<T extends AssocEdge> {

package/core/ent.js

@@ -32,9 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assocEdgeLoader = exports.AssocEdgeData = exports.AssocEdge = void 0;
 exports.rowIsError = rowIsError;
@@ -90,7 +87,7 @@ exports.applyPrivacyPolicyForRows = applyPrivacyPolicyForRows;
 exports.getEdgeTypeInGroup = getEdgeTypeInGroup;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
-const dataloader_1 = __importDefault(require("dataloader"));
+const async_utils_1 = require("./async_utils");
 const clause = __importStar(require("./clause"));
 const global_schema_1 = require("./global_schema");
 const loader_1 = require("./loaders/loader");
@@ -125,15 +122,13 @@ class entCacheMap {
     }
 }
 function createAssocEdgeConfigLoader(options) {
+    const loaderName = `assocEdgeConfigLoader:${options.tableName}`;
     const loaderOptions = {
         maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+        cacheMap: (0, loader_1.createLoaderCacheMap)(options),
     };
-    // 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);
-    }
     // something here brokwn with strict:true
-    return new dataloader_1.default(async (ids) => {
+    return new loader_1.InstrumentedDataLoader(loaderName, async (ids) => {
         if (!ids.length) {
             return [];
         }
@@ -155,7 +150,7 @@ function createAssocEdgeConfigLoader(options) {
             }
         }
         return ids.map((id) => rowMap.get(id) ?? null);
-    }, loaderOptions);
+    }, loaderOptions, options.tableName);
 }
 // used to wrap errors that would eventually be thrown in ents
 // not an Error because DataLoader automatically rejects that
@@ -177,48 +172,23 @@ function setEntLoaderPrivacyConcurrencyLimit(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) {
+    const loaderName = `entLoader:${options.loaderFactory.name}`;
+    const tableName = options.loaderFactory.options?.tableName;
     // share the cache across loaders even if we create a new instance
     const loaderOptions = {
         maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
     };
-    loaderOptions.cacheMap = map;
-    return new dataloader_1.default(async (ids) => {
+    loaderOptions.cacheMap = (0, loader_1.createBoundedCacheMap)(map);
+    return new loader_1.InstrumentedDataLoader(loaderName, async (ids) => {
         if (!ids.length) {
             return [];
         }
-        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...
-        return mapWithConcurrency(rows, getEntLoaderPrivacyConcurrencyLimit(), async (row, idx) => {
+        return (0, async_utils_1.mapWithConcurrency)(rows, getEntLoaderPrivacyConcurrencyLimit(), async (row, idx) => {
             // db error
             if (rowIsError(row)) {
                 if (row instanceof Error) {
@@ -239,7 +209,7 @@ function createEntLoader(viewer, options, map) {
             }
             return r;
         });
-    }, loaderOptions);
+    }, loaderOptions, tableName);
 }
 class EntLoader {
     constructor(viewer, options) {

package/core/loaders/assoc_count_loader.js

@@ -63,7 +63,7 @@ class AssocEdgeCountLoader {
             tableName: edgeData.edgeTable,
             groupCol: "id1",
             clause: cls,
-        });
+        }, this.context);
         return this.loader;
     }
     async load(id) {

package/core/loaders/assoc_edge_loader.d.ts

@@ -23,7 +23,10 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeCtr;
     private options?;
     context?: Context | undefined;
+    private loader;
+    private loaderFn;
     constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: EdgeQueryableDataOptions | undefined, context?: Context | undefined);
+    private getLoader;
     load(id: ID): Promise<T[]>;
     loadTwoWay(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;

package/core/loaders/assoc_edge_loader.js

@@ -37,12 +37,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssocEdgeLoaderFactory = exports.AssocDirectEdgeLoader = exports.AssocEdgeLoader = void 0;
-const dataloader_1 = __importDefault(require("dataloader"));
 const memoizee_1 = __importDefault(require("memoizee"));
 const clause = __importStar(require("../clause"));
 const ent_1 = require("../ent");
-const logger_1 = require("../logger");
-const cache_utils_1 = require("./cache_utils");
+const cache_utils_1 = require("../cache_utils");
 const loader_1 = require("./loader");
 function getDefaultOrderBy() {
     return [
@@ -60,16 +58,15 @@ function getEffectiveOptions(options) {
         disableTransformations: options.disableTransformations ?? false,
     };
 }
-function createLoader(options, edgeType, edgeCtr, edgeData) {
+function createLoader(options, edgeType, edgeCtr, edgeData, context) {
+    const loaderName = `assocEdgeLoader:${edgeType}`;
     const loaderOptions = {
         maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
-    };
-    if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new loader_1.CacheMap({
+        cacheMap: (0, loader_1.createLoaderCacheMap)({
             tableName: edgeData.edgeTable,
-        });
-    }
-    return new dataloader_1.default(async (keys) => {
+        }),
+    };
+    return new loader_1.InstrumentedDataLoader(loaderName, async (keys) => {
         if (keys.length === 1) {
             // 1 key, just be simple and move on
             // same as AssocDirectEdgeLoader
@@ -77,6 +74,7 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
                 id1: keys[0],
                 edgeType: edgeType,
                 queryOptions: options,
+                context,
                 ctr: edgeCtr,
             });
             return [r];
@@ -115,7 +113,7 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
             result[idx].push(new edgeCtr(row));
         }
         return result;
-    }, loaderOptions);
+    }, loaderOptions, edgeData.edgeTable);
 }
 class AssocEdgeLoader {
     constructor(edgeType, edgeCtr, options, context) {
@@ -130,7 +128,7 @@ class AssocEdgeLoader {
         if (!edgeData) {
             throw new Error(`error loading edge data for ${this.edgeType}`);
         }
-        this.loader = createLoader(this.options, this.edgeType, this.edgeCtr, edgeData);
+        this.loader = createLoader(this.options, this.edgeType, this.edgeCtr, edgeData, this.context);
         return this.loader;
     }
     async load(id) {
@@ -168,8 +166,40 @@ class AssocDirectEdgeLoader {
         this.edgeCtr = edgeCtr;
         this.options = options;
         this.context = context;
+        if (this.context) {
+            this.loaderFn = (0, memoizee_1.default)(this.getLoader);
+        }
+    }
+    async getLoader() {
+        if (this.loader) {
+            return this.loader;
+        }
+        const edgeData = await (0, ent_1.loadEdgeData)(this.edgeType);
+        if (!edgeData) {
+            throw new Error(`error loading edge data for ${this.edgeType}`);
+        }
+        const loaderName = `assocDirectEdgeLoader:${this.edgeType}`;
+        this.loader = new loader_1.InstrumentedDataLoader(loaderName, async (keys) => {
+            return Promise.all(keys.map((id) => (0, ent_1.loadCustomEdges)({
+                id1: id,
+                edgeType: this.edgeType,
+                context: this.context,
+                queryOptions: this.options,
+                ctr: this.edgeCtr,
+            })));
+        }, {
+            maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+            cacheMap: (0, loader_1.createLoaderCacheMap)({
+                tableName: edgeData.edgeTable,
+            }),
+        }, edgeData.edgeTable);
+        return this.loader;
     }
     async load(id) {
+        if (this.loaderFn) {
+            const loader = await this.loaderFn();
+            return loader.load(id);
+        }
         return (0, ent_1.loadCustomEdges)({
             id1: id,
             edgeType: this.edgeType,
@@ -197,7 +227,9 @@ class AssocDirectEdgeLoader {
             ctr: this.edgeCtr,
         });
     }
-    clearAll() { }
+    clearAll() {
+        this.loader && this.loader.clearAll();
+    }
 }
 exports.AssocDirectEdgeLoader = AssocDirectEdgeLoader;
 class AssocEdgeLoaderFactory {

package/core/loaders/index.d.ts

@@ -3,4 +3,5 @@ export { RawCountLoader, RawCountLoaderFactory } from "./raw_count_loader";
 export { AssocEdgeCountLoader, AssocEdgeCountLoaderFactory, } from "./assoc_count_loader";
 export { AssocDirectEdgeLoader, AssocEdgeLoader, AssocEdgeLoaderFactory, } from "./assoc_edge_loader";
 export { QueryLoaderFactory } from "./query_loader";
-export { getLoaderMaxBatchSize, setLoaderMaxBatchSize } from "./loader";
+export { getLoaderCacheMaxEntries, getLoaderMaxBatchSize, setLoaderCacheMaxEntries, setLoaderMaxBatchSize, } from "./loader";
+export { setClauseLoaderConcurrency } from "./object_loader";

package/core/loaders/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setLoaderMaxBatchSize = exports.getLoaderMaxBatchSize = exports.QueryLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
+exports.setClauseLoaderConcurrency = exports.setLoaderMaxBatchSize = exports.setLoaderCacheMaxEntries = exports.getLoaderMaxBatchSize = exports.getLoaderCacheMaxEntries = exports.QueryLoaderFactory = 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,5 +17,9 @@ Object.defineProperty(exports, "AssocEdgeLoaderFactory", { enumerable: true, get
 var query_loader_1 = require("./query_loader");
 Object.defineProperty(exports, "QueryLoaderFactory", { enumerable: true, get: function () { return query_loader_1.QueryLoaderFactory; } });
 var loader_1 = require("./loader");
+Object.defineProperty(exports, "getLoaderCacheMaxEntries", { enumerable: true, get: function () { return loader_1.getLoaderCacheMaxEntries; } });
 Object.defineProperty(exports, "getLoaderMaxBatchSize", { enumerable: true, get: function () { return loader_1.getLoaderMaxBatchSize; } });
+Object.defineProperty(exports, "setLoaderCacheMaxEntries", { enumerable: true, get: function () { return loader_1.setLoaderCacheMaxEntries; } });
 Object.defineProperty(exports, "setLoaderMaxBatchSize", { enumerable: true, get: function () { return loader_1.setLoaderMaxBatchSize; } });
+var object_loader_2 = require("./object_loader");
+Object.defineProperty(exports, "setClauseLoaderConcurrency", { enumerable: true, get: function () { return object_loader_2.setClauseLoaderConcurrency; } });

package/core/loaders/loader.d.ts

@@ -1,8 +1,38 @@
+import DataLoader from "dataloader";
 import { Loader, LoaderFactory, Context, DataOptions } from "../base";
 export declare function getLoaderMaxBatchSize(): number;
 export declare function setLoaderMaxBatchSize(size?: number | null): void;
+export declare function getLoaderCacheMaxEntries(): number;
+export declare function setLoaderCacheMaxEntries(size?: number | null): void;
 export declare function getLoader<K, V>(factory: LoaderFactory<K, V>, create: () => Loader<K, V>, context?: Context): Loader<K, V>;
 export declare function getCustomLoader<K, V>(key: string, create: () => Loader<K, V>, context?: Context): Loader<K, V>;
+export type CacheMapLike<K, V> = {
+    get(key: K): V | undefined;
+    set(key: K, value: V): any;
+    delete(key: K): any;
+    clear(): any;
+};
+type CacheKeyFn<K> = (key: K) => any;
+type BatchLoadFn<K, V> = (keys: readonly K[]) => PromiseLike<ArrayLike<V | Error>>;
+export declare class InstrumentedDataLoader<K, V> extends DataLoader<K, V> {
+    constructor(loaderName: string, batchLoadFn: BatchLoadFn<K, V>, options: DataLoader.Options<K, V>, tableName?: string, cacheKeyFn?: (key: K) => unknown);
+}
+export declare class BoundedCacheMap<K, V> {
+    private cacheMap;
+    private maxEntries;
+    private cacheKeyFn?;
+    private order;
+    constructor(cacheMap: CacheMapLike<K, V>, maxEntries: number, cacheKeyFn?: CacheKeyFn<K> | undefined);
+    private normalizeKey;
+    private touch;
+    private evictIfNeeded;
+    get(key: K): V | undefined;
+    set(key: K, value: V): any;
+    delete(key: K): any;
+    clear(): any;
+}
+export declare function createBoundedCacheMap<K, V>(cacheMap: CacheMapLike<K, V>, cacheKeyFn?: CacheKeyFn<K>): CacheMapLike<K, V>;
+export declare function createLoaderCacheMap<K, V>(options: DataOptions): CacheMapLike<K, V>;
 export declare class CacheMap {
     private options;
     private m;
@@ -12,3 +42,4 @@ export declare class CacheMap {
     delete(key: any): boolean;
     clear(): void;
 }
+export {};