@snowtop/ent 0.2.5 → 0.2.7

package/core/loaders/object_loader.js

@@ -15,33 +15,59 @@ 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.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = void 0;
-const dataloader_1 = __importDefault(require("dataloader"));
+exports.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = exports.mapWithConcurrency = void 0;
+exports.setClauseLoaderConcurrency = setClauseLoaderConcurrency;
 const ent_1 = require("../ent");
+const async_utils_1 = require("../async_utils");
+Object.defineProperty(exports, "mapWithConcurrency", { enumerable: true, get: function () { return async_utils_1.mapWithConcurrency; } });
 const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const clause_1 = require("../clause");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
+const DEFAULT_CLAUSE_LOADER_CONCURRENCY = 10;
+let clauseLoaderConcurrency = DEFAULT_CLAUSE_LOADER_CONCURRENCY;
+function setClauseLoaderConcurrency(limit) {
+    if (!Number.isFinite(limit) || limit < 1) {
+        clauseLoaderConcurrency = DEFAULT_CLAUSE_LOADER_CONCURRENCY;
+        return;
+    }
+    clauseLoaderConcurrency = Math.floor(limit);
+}
 async function loadRowsForIDLoader(options, ids, context) {
     let col = options.key;
-    const cls = (0, clause_1.getCombinedClause)(options, clause.DBTypeIn(col, ids, options.keyType || "uuid"));
-    const rowOptions = {
-        ...options,
-        clause: cls,
-        context,
-    };
+    const typ = options.keyType || "uuid";
+    const maxBatchSize = (0, loader_1.getLoaderMaxBatchSize)();
+    const batches = [];
+    if (maxBatchSize > 0 && ids.length > maxBatchSize) {
+        for (let i = 0; i < ids.length; i += maxBatchSize) {
+            batches.push(ids.slice(i, i + maxBatchSize));
+        }
+    }
+    else {
+        batches.push(ids);
+    }
     let m = new Map();
     let result = [];
     for (let i = 0; i < ids.length; i++) {
@@ -49,33 +75,43 @@ async function loadRowsForIDLoader(options, ids, context) {
         // 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`);
+    for (const batch of batches) {
+        const cls = (0, clause_1.getCombinedClause)(options, clause.DBTypeIn(col, batch, typ));
+        const rowOptions = {
+            ...options,
+            clause: cls,
+            context,
+        };
+        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;
         }
-        result[idx] = row;
     }
     return result;
 }
-async function loadRowsForClauseLoader(options, clause) {
+async function loadRowsForClauseLoader(options, clause, context) {
     const rowOptions = {
         ...options,
         // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
         clause: (0, clause_1.getCombinedClause)(options, clause, true),
+        context,
     };
     return (await (0, ent_1.loadRows)(rowOptions));
 }
-async function loadCountForClauseLoader(options, clause) {
+async function loadCountForClauseLoader(options, clause, context) {
     const rowOptions = {
         ...options,
         // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
         clause: (0, clause_1.getCombinedClause)(options, clause, true),
+        context,
     };
     const row = await (0, ent_1.loadRow)({
         ...rowOptions,
@@ -89,19 +125,19 @@ async function loadCountForClauseLoader(options, clause) {
 // optional clause...
 // so ObjectLoaderFactory and createDataLoader need to take a new optional field which is a clause that's always added here
 // and we need a disableTransform which skips loader completely and uses loadRow...
-function createDataLoader(options) {
-    const loaderOptions = {};
-    // if query logging is enabled, we should log what's happening with loader
-    if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new loader_1.CacheMap(options);
-    }
-    return new dataloader_1.default(async (ids) => {
+function createDataLoader(options, context) {
+    const loaderName = `objectLoader:${options.tableName}:${options.key}`;
+    const loaderOptions = {
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+        cacheMap: (0, loader_1.createLoaderCacheMap)(options),
+    };
+    return new loader_1.InstrumentedDataLoader(loaderName, async (ids) => {
         if (!ids.length) {
             return [];
         }
-        // context not needed because we're creating a loader which has its own cache which is being used here
-        return loadRowsForIDLoader(options, ids);
-    }, loaderOptions);
+        // pass context along so ContextCache is primed alongside DataLoader caching
+        return loadRowsForIDLoader(options, ids, context);
+    }, loaderOptions, options.tableName);
 }
 class clauseCacheMap {
     constructor(options, count) {
@@ -130,35 +166,32 @@ class clauseCacheMap {
         return this.m.clear();
     }
 }
-function createClauseDataLoder(options) {
-    return new dataloader_1.default(async (clauses) => {
+function createClauseCacheMap(options, count) {
+    return (0, loader_1.createBoundedCacheMap)(new clauseCacheMap(options, count), (key) => key.instanceKey());
+}
+function createClauseDataLoder(options, context) {
+    const loaderName = `objectLoader:clause:${options.tableName}`;
+    return new loader_1.InstrumentedDataLoader(loaderName, async (clauses) => {
         if (!clauses.length) {
             return [];
         }
-        const ret = [];
-        for await (const clause of clauses) {
-            const data = await loadRowsForClauseLoader(options, clause);
-            ret.push(data);
-        }
-        return ret;
+        return (0, async_utils_1.mapWithConcurrency)(clauses, clauseLoaderConcurrency, (clauseItem) => loadRowsForClauseLoader(options, clauseItem, context));
     }, {
-        cacheMap: new clauseCacheMap(options),
-    });
+        cacheMap: createClauseCacheMap(options),
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+    }, options.tableName, (key) => key.instanceKey());
 }
-function createClauseCountDataLoader(options) {
-    return new dataloader_1.default(async (clauses) => {
+function createClauseCountDataLoader(options, context) {
+    const loaderName = `objectLoader:count:${options.tableName}`;
+    return new loader_1.InstrumentedDataLoader(loaderName, async (clauses) => {
         if (!clauses.length) {
             return [];
         }
-        const ret = [];
-        for await (const clause of clauses) {
-            const data = await loadCountForClauseLoader(options, clause);
-            ret.push(data);
-        }
-        return ret;
+        return (0, async_utils_1.mapWithConcurrency)(clauses, clauseLoaderConcurrency, (clauseItem) => loadCountForClauseLoader(options, clauseItem, context));
     }, {
-        cacheMap: new clauseCacheMap(options, true),
-    });
+        cacheMap: createClauseCacheMap(options, true),
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+    }, options.tableName, (key) => `${key.instanceKey()}:count`);
 }
 class ObjectLoader {
     constructor(options, context, toPrime) {
@@ -169,8 +202,8 @@ class ObjectLoader {
             console.trace();
         }
         if (context) {
-            this.idLoader = createDataLoader(options);
-            this.clauseLoader = createClauseDataLoder(options);
+            this.idLoader = createDataLoader(options, context);
+            this.clauseLoader = createClauseDataLoder(options, context);
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
@@ -225,7 +258,7 @@ class ObjectLoader {
         if (this.clauseLoader) {
             return this.clauseLoader.load(key);
         }
-        return loadRowsForClauseLoader(this.options, key);
+        return loadRowsForClauseLoader(this.options, key, this.context);
     }
     clearAll() {
         this.idLoader && this.idLoader.clearAll();
@@ -252,12 +285,7 @@ class ObjectLoader {
             // @ts-expect-error TODO?
             return this.clauseLoader.loadMany(keys);
         }
-        const res = [];
-        for await (const key of keys) {
-            const rows = await loadRowsForClauseLoader(this.options, key);
-            res.push(rows);
-        }
-        return res;
+        return (0, async_utils_1.mapWithConcurrency)(keys, clauseLoaderConcurrency, (key) => loadRowsForClauseLoader(this.options, key, this.context));
     }
     prime(data) {
         // we have this data from somewhere else, prime it in the c
@@ -286,7 +314,7 @@ class ObjectCountLoader {
         this.options = options;
         this.context = context;
         if (context) {
-            this.loader = createClauseCountDataLoader(options);
+            this.loader = createClauseCountDataLoader(options, context);
         }
     }
     getOptions() {
@@ -296,7 +324,7 @@ class ObjectCountLoader {
         if (this.loader) {
             return this.loader.load(key);
         }
-        return loadCountForClauseLoader(this.options, key);
+        return loadCountForClauseLoader(this.options, key, this.context);
     }
     clearAll() {
         this.loader && this.loader.clearAll();
@@ -309,12 +337,7 @@ class ObjectCountLoader {
             // @ts-expect-error
             return this.loader.loadMany(keys);
         }
-        const res = [];
-        for await (const key of keys) {
-            const r = await loadCountForClauseLoader(this.options, key);
-            res.push(r);
-        }
-        return res;
+        return (0, async_utils_1.mapWithConcurrency)(keys, clauseLoaderConcurrency, (key) => loadCountForClauseLoader(this.options, key, this.context));
     }
 }
 exports.ObjectCountLoader = ObjectCountLoader;

package/core/loaders/query_loader.d.ts

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

package/core/loaders/query_loader.js

@@ -15,23 +15,32 @@ 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.QueryLoaderFactory = 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 loader_1 = require("./loader");
 function getOrderByLocal(options, queryOptions) {
     return (options.orderby ??
@@ -42,7 +51,7 @@ function getOrderByLocal(options, queryOptions) {
         },
     ]);
 }
-async function simpleCase(options, id, queryOptions) {
+async function simpleCase(options, id, queryOptions, context) {
     let cls;
     if (options.groupCol) {
         cls = clause.Eq(options.groupCol, id);
@@ -65,22 +74,27 @@ async function simpleCase(options, id, queryOptions) {
         clause: cls,
         orderby: getOrderByLocal(options, queryOptions),
         limit: queryOptions?.limit || (0, ent_1.getDefaultLimit)(),
+        context,
     });
 }
-function createLoader(options, queryOptions) {
-    const loaderOptions = {};
-    // 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);
-    }
-    return new dataloader_1.default(async (keys) => {
+function createLoader(options, queryOptions, context) {
+    const loaderName = options.groupCol
+        ? `queryLoader:${options.tableName}:${options.groupCol}`
+        : options.clause
+            ? `queryLoader:${options.tableName}:${options.clause.instanceKey()}`
+            : `queryLoader:${options.tableName}`;
+    const loaderOptions = {
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+        cacheMap: (0, loader_1.createLoaderCacheMap)(options),
+    };
+    return new loader_1.InstrumentedDataLoader(loaderName, async (keys) => {
         if (!keys.length) {
             return [];
         }
         // keep query simple if we're only fetching for one id
         // or can't group because no groupCol...
         if (keys.length == 1 || !options.groupCol) {
-            const rows = await simpleCase(options, keys[0], queryOptions);
+            const rows = await simpleCase(options, keys[0], queryOptions, context);
             return [rows];
         }
         let m = new Map();
@@ -121,7 +135,7 @@ function createLoader(options, queryOptions) {
             result[idx].push(row);
         }
         return result;
-    }, loaderOptions);
+    }, loaderOptions, options.tableName);
 }
 class QueryDirectLoader {
     constructor(options, queryOptions, context) {
@@ -145,7 +159,7 @@ class QueryDirectLoader {
         this.primedLoaders = primedLoaders;
     }
     async load(id) {
-        const rows = await simpleCase(this.options, id, this.queryOptions);
+        const rows = await simpleCase(this.options, id, this.queryOptions, this.context);
         if (this.context) {
             this.memoizedInitPrime();
             if (this.primedLoaders) {
@@ -171,7 +185,7 @@ class QueryLoader {
         this.context = context;
         this.queryOptions = queryOptions;
         if (context) {
-            this.loader = createLoader(options, queryOptions);
+            this.loader = createLoader(options, queryOptions, context);
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
@@ -205,7 +219,7 @@ class QueryLoader {
             }
             return rows;
         }
-        return simpleCase(this.options, id, this.queryOptions);
+        return simpleCase(this.options, id, this.queryOptions, this.context);
     }
     clearAll() {
         this.loader && this.loader.clearAll();
@@ -231,10 +245,32 @@ class QueryLoaderFactory {
         return QueryLoaderFactory.createConfigurableLoader(this.name, this.options, options, context);
     }
     static createConfigurableLoader(name, queryOptions, options, context) {
-        if (options.clause || !context) {
+        if (!context) {
             return new QueryDirectLoader(queryOptions, options, context);
         }
-        const key = `${name}:limit:${options.limit}:orderby:${options.orderby}`;
+        if (options.clause) {
+            const effectiveOrderBy = getOrderByLocal(queryOptions, options);
+            const effectiveLimit = options.limit || (0, ent_1.getDefaultLimit)();
+            const disableTransformations = options.disableTransformations ?? false;
+            const keyParts = [
+                name,
+                `clause:${options.clause.instanceKey()}`,
+                queryOptions.clause
+                    ? `baseClause:${queryOptions.clause.instanceKey()}`
+                    : undefined,
+                `limit:${effectiveLimit}`,
+                `orderby:${(0, cache_utils_1.stableStringify)(effectiveOrderBy)}`,
+                `disableTransformations:${disableTransformations}`,
+            ];
+            const key = keyParts
+                .filter((part) => Boolean(part))
+                .join(":");
+            return (0, loader_1.getCustomLoader)(key, () => new QueryDirectLoader(queryOptions, options, context), context);
+        }
+        const effectiveOrderBy = getOrderByLocal(queryOptions, options);
+        const effectiveLimit = options.limit || (0, ent_1.getDefaultLimit)();
+        const disableTransformations = options.disableTransformations ?? false;
+        const key = `${name}:limit:${effectiveLimit}:orderby:${(0, cache_utils_1.stableStringify)(effectiveOrderBy)}:disableTransformations:${disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(queryOptions, context, options), context);
     }
 }

package/core/loaders/raw_count_loader.d.ts

@@ -1,18 +1,18 @@
-import DataLoader from "dataloader";
 import { ID, Context, Loader, LoaderFactory, SelectBaseDataOptions } from "../base";
 import * as clause from "../clause";
+import { InstrumentedDataLoader } from "./loader";
 interface QueryCountOptions {
     tableName: string;
     groupCol?: string;
     groupColType?: string;
     clause?: clause.Clause;
 }
-export declare function createCountDataLoader<K extends any>(options: QueryCountOptions): DataLoader<K, number, K>;
+export declare function createCountDataLoader<K extends any>(options: QueryCountOptions, context?: Context): InstrumentedDataLoader<K, number>;
 export declare class RawCountLoader<K extends any> implements Loader<K, number> {
     private options;
-    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    context?: Context | undefined;
     private loader;
-    constructor(options: QueryCountOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(options: QueryCountOptions, context?: Context | undefined);
     load(id: K): Promise<number>;
     clearAll(): void;
 }

package/core/loaders/raw_count_loader.js

@@ -15,22 +15,28 @@ 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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+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.RawCountLoaderFactory = exports.RawCountLoader = exports.createCountDataLoader = void 0;
-const dataloader_1 = __importDefault(require("dataloader"));
+exports.RawCountLoaderFactory = exports.RawCountLoader = void 0;
+exports.createCountDataLoader = createCountDataLoader;
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
-const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 async function simpleCase(options, key, context) {
     let cls;
@@ -55,19 +61,23 @@ async function simpleCase(options, key, context) {
     });
     return [parseInt(row?.count, 10) || 0];
 }
-function createCountDataLoader(options) {
-    const loaderOptions = {};
-    // 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);
-    }
-    return new dataloader_1.default(async (keys) => {
+function createCountDataLoader(options, context) {
+    const loaderName = options.groupCol
+        ? `rawCountLoader:${options.tableName}:${options.groupCol}`
+        : options.clause
+            ? `rawCountLoader:${options.tableName}:${options.clause.instanceKey()}`
+            : `rawCountLoader:${options.tableName}`;
+    const loaderOptions = {
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+        cacheMap: (0, loader_1.createLoaderCacheMap)(options),
+    };
+    return new loader_1.InstrumentedDataLoader(loaderName, async (keys) => {
         if (!keys.length) {
             return [];
         }
         // keep query simple if we're only fetching for one id
         if (keys.length == 1 || !options.groupCol) {
-            return simpleCase(options, keys[0]);
+            return simpleCase(options, keys[0], context);
         }
         let typ = options.groupColType || "uuid";
         let cls = clause.DBTypeIn(options.groupCol, keys, typ);
@@ -86,6 +96,7 @@ function createCountDataLoader(options) {
             fields: ["count(1) as count", options.groupCol],
             groupby: options.groupCol,
             clause: cls,
+            context,
         };
         const rows = await (0, ent_1.loadRows)(rowOptions);
         for (const row of rows) {
@@ -97,9 +108,8 @@ function createCountDataLoader(options) {
             result[idx] = parseInt(row.count, 10);
         }
         return result;
-    }, loaderOptions);
+    }, loaderOptions, options.tableName);
 }
-exports.createCountDataLoader = createCountDataLoader;
 // for now this only works for single column counts
 // e.g. foreign key count
 class RawCountLoader {
@@ -108,7 +118,7 @@ class RawCountLoader {
         this.options = options;
         this.context = context;
         if (context && options.groupCol) {
-            this.loader = createCountDataLoader(options);
+            this.loader = createCountDataLoader(options, context);
         }
     }
     async load(id) {

package/core/logger.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logEnabled = exports.logTrace = exports.logIf = exports.log = exports.clearLogLevels = exports.setLogLevels = void 0;
+exports.setLogLevels = setLogLevels;
+exports.clearLogLevels = clearLogLevels;
+exports.log = log;
+exports.logIf = logIf;
+exports.logTrace = logTrace;
+exports.logEnabled = logEnabled;
 var m = {
     query: "log",
     warn: "warn",
@@ -16,11 +21,9 @@ function setLogLevels(levels) {
     }
     levels.forEach((level) => logLevels.set(level, true));
 }
-exports.setLogLevels = setLogLevels;
 function clearLogLevels() {
     logLevels.clear();
 }
-exports.clearLogLevels = clearLogLevels;
 function log(level, msg) {
     if (logLevels.has(level)) {
         // mostly for sqlite error but fine for any type of error
@@ -32,20 +35,16 @@ function log(level, msg) {
         console[m[level]](msg);
     }
 }
-exports.log = log;
 function logIf(level, logFn) {
     if (logLevels.has(level)) {
         console[m[level]](logFn());
     }
 }
-exports.logIf = logIf;
 function logTrace() {
     if (logLevels.has("debug")) {
         console.trace();
     }
 }
-exports.logTrace = logTrace;
 function logEnabled(level) {
     return logLevels.has(level);
 }
-exports.logEnabled = logEnabled;

package/core/metrics.d.ts

@@ -0,0 +1,22 @@
+export type DataLoaderBatchMetrics = {
+    loaderName: string;
+    batchSize: number;
+};
+export type DataLoaderCacheHitMetrics = {
+    tableName: string;
+    key: unknown;
+};
+export type QueryCacheHitMetrics = {
+    tableName: string;
+    key: string;
+};
+export type MetricsHook = {
+    onDataLoaderBatch?: (info: DataLoaderBatchMetrics) => void;
+    onDataLoaderCacheHit?: (info: DataLoaderCacheHitMetrics) => void;
+    onQueryCacheHit?: (info: QueryCacheHitMetrics) => void;
+};
+export declare function setMetricsHook(hooks?: MetricsHook | null): void;
+export declare function getMetricsHook(): MetricsHook;
+export declare function getOnDataLoaderBatch(): ((info: DataLoaderBatchMetrics) => void) | undefined;
+export declare function getOnDataLoaderCacheHit(): ((info: DataLoaderCacheHitMetrics) => void) | undefined;
+export declare function getOnQueryCacheHit(): ((info: QueryCacheHitMetrics) => void) | undefined;