@snowtop/ent 0.2.6 → 0.2.8

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 {};

package/core/loaders/loader.js

@@ -1,13 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheMap = void 0;
+exports.CacheMap = exports.BoundedCacheMap = exports.InstrumentedDataLoader = void 0;
 exports.getLoaderMaxBatchSize = getLoaderMaxBatchSize;
 exports.setLoaderMaxBatchSize = setLoaderMaxBatchSize;
+exports.getLoaderCacheMaxEntries = getLoaderCacheMaxEntries;
+exports.setLoaderCacheMaxEntries = setLoaderCacheMaxEntries;
 exports.getLoader = getLoader;
 exports.getCustomLoader = getCustomLoader;
+exports.createBoundedCacheMap = createBoundedCacheMap;
+exports.createLoaderCacheMap = createLoaderCacheMap;
+const dataloader_1 = __importDefault(require("dataloader"));
 const logger_1 = require("../logger");
+const metrics_1 = require("../metrics");
 const DEFAULT_MAX_BATCH_SIZE = 1000;
 let loaderMaxBatchSize = DEFAULT_MAX_BATCH_SIZE;
+const DEFAULT_MAX_CACHE_ENTRIES = 1000;
+let loaderCacheMaxEntries = DEFAULT_MAX_CACHE_ENTRIES;
 function getLoaderMaxBatchSize() {
     return loaderMaxBatchSize;
 }
@@ -21,6 +32,19 @@ function setLoaderMaxBatchSize(size) {
     }
     loaderMaxBatchSize = Math.floor(size);
 }
+function getLoaderCacheMaxEntries() {
+    return loaderCacheMaxEntries;
+}
+function setLoaderCacheMaxEntries(size) {
+    if (size === undefined || size === null) {
+        loaderCacheMaxEntries = DEFAULT_MAX_CACHE_ENTRIES;
+        return;
+    }
+    if (!Number.isFinite(size) || size < 0) {
+        throw new Error(`maxCacheEntries must be a non-negative number`);
+    }
+    loaderCacheMaxEntries = Math.floor(size);
+}
 // this is like factory factory FML
 // helper function to handle context vs not
 // and to keep the API clean for clients who shouldn't have to worry about this
@@ -42,6 +66,121 @@ function getCustomLoader(key, create, context) {
     // g|set from context cache
     return context.cache.getLoader(key, create);
 }
+function instrumentCacheMap(cacheMap, tableName, cacheKeyFn) {
+    if (!cacheMap || !tableName) {
+        return cacheMap;
+    }
+    return {
+        get(key) {
+            const value = cacheMap.get(key);
+            if (value !== undefined) {
+                const hook = (0, metrics_1.getOnDataLoaderCacheHit)();
+                if (hook) {
+                    hook({
+                        tableName,
+                        key: cacheKeyFn ? cacheKeyFn(key) : key,
+                    });
+                }
+            }
+            return value;
+        },
+        set(key, value) {
+            return cacheMap.set(key, value);
+        },
+        delete(key) {
+            return cacheMap.delete(key);
+        },
+        clear() {
+            return cacheMap.clear();
+        },
+    };
+}
+class InstrumentedDataLoader extends dataloader_1.default {
+    constructor(loaderName, batchLoadFn, options, tableName, cacheKeyFn) {
+        const wrappedBatchFn = async (keys) => {
+            if (keys.length) {
+                const hook = (0, metrics_1.getOnDataLoaderBatch)();
+                if (hook) {
+                    hook({
+                        loaderName,
+                        batchSize: keys.length,
+                    });
+                }
+            }
+            return batchLoadFn(keys);
+        };
+        const cacheMap = instrumentCacheMap(options.cacheMap, tableName, cacheKeyFn);
+        const loaderOptions = cacheMap === options.cacheMap ? options : { ...options, cacheMap };
+        super(wrappedBatchFn, loaderOptions);
+    }
+}
+exports.InstrumentedDataLoader = InstrumentedDataLoader;
+class BoundedCacheMap {
+    constructor(cacheMap, maxEntries, cacheKeyFn) {
+        this.cacheMap = cacheMap;
+        this.maxEntries = maxEntries;
+        this.cacheKeyFn = cacheKeyFn;
+        this.order = new Map();
+    }
+    normalizeKey(key) {
+        return this.cacheKeyFn ? this.cacheKeyFn(key) : key;
+    }
+    touch(normalizedKey, key) {
+        if (this.order.has(normalizedKey)) {
+            this.order.delete(normalizedKey);
+        }
+        this.order.set(normalizedKey, key);
+    }
+    evictIfNeeded() {
+        while (this.order.size > this.maxEntries) {
+            const oldest = this.order.entries().next().value;
+            if (!oldest) {
+                return;
+            }
+            const [normalizedKey, key] = oldest;
+            this.order.delete(normalizedKey);
+            this.cacheMap.delete(key);
+        }
+    }
+    get(key) {
+        const value = this.cacheMap.get(key);
+        if (value !== undefined) {
+            const normalizedKey = this.normalizeKey(key);
+            this.touch(normalizedKey, key);
+        }
+        return value;
+    }
+    set(key, value) {
+        const normalizedKey = this.normalizeKey(key);
+        this.touch(normalizedKey, key);
+        const result = this.cacheMap.set(key, value);
+        this.evictIfNeeded();
+        return result;
+    }
+    delete(key) {
+        const normalizedKey = this.normalizeKey(key);
+        this.order.delete(normalizedKey);
+        return this.cacheMap.delete(key);
+    }
+    clear() {
+        this.order.clear();
+        return this.cacheMap.clear();
+    }
+}
+exports.BoundedCacheMap = BoundedCacheMap;
+function createBoundedCacheMap(cacheMap, cacheKeyFn) {
+    const maxEntries = getLoaderCacheMaxEntries();
+    if (maxEntries <= 0) {
+        return cacheMap;
+    }
+    return new BoundedCacheMap(cacheMap, maxEntries, cacheKeyFn);
+}
+function createLoaderCacheMap(options) {
+    const baseMap = (0, logger_1.logEnabled)("query")
+        ? new CacheMap(options)
+        : new Map();
+    return createBoundedCacheMap(baseMap);
+}
 class CacheMap {
     constructor(options) {
         this.options = options;
@@ -56,7 +195,7 @@ class CacheMap {
             // was designed for ObjectLoader time. Now we have different needs e.g. count, assoc etc
             (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key,
-                "tableName": this.options.tableName,
+                tableName: this.options.tableName,
             });
         }
         return ret;

package/core/loaders/object_loader.d.ts

@@ -1,7 +1,8 @@
 import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
+import { mapWithConcurrency } from "../async_utils";
 import * as clause from "../clause";
 export declare function setClauseLoaderConcurrency(limit: number): void;
-export declare function mapWithConcurrency<T, R>(items: T[], limit: number, mapper: (item: T, index: number) => Promise<R>): Promise<R[]>;
+export { mapWithConcurrency };
 export declare class ObjectLoader<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData> implements Loader<ID, TResultData | null>, Loader<clause.Clause<TQueryData, K>, TResultData[] | null> {
     private options;
     context?: Context | undefined;
@@ -48,4 +49,3 @@ export declare class ObjectLoaderFactory<V extends Data = Data> implements Loade
     createCountLoader<K = keyof V>(context?: Context): ObjectCountLoader<V, K>;
     addToPrime(factory: ObjectLoaderFactory<V>): this;
 }
-export {};

package/core/loaders/object_loader.js

@@ -32,20 +32,17 @@ 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.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = void 0;
+exports.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = exports.mapWithConcurrency = void 0;
 exports.setClauseLoaderConcurrency = setClauseLoaderConcurrency;
-exports.mapWithConcurrency = mapWithConcurrency;
-const dataloader_1 = __importDefault(require("dataloader"));
 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 memoize_1 = require("../memoize");
 const DEFAULT_CLAUSE_LOADER_CONCURRENCY = 10;
 let clauseLoaderConcurrency = DEFAULT_CLAUSE_LOADER_CONCURRENCY;
 function setClauseLoaderConcurrency(limit) {
@@ -55,26 +52,6 @@ function setClauseLoaderConcurrency(limit) {
     }
     clauseLoaderConcurrency = Math.floor(limit);
 }
-async function mapWithConcurrency(items, limit, mapper) {
-    if (!items.length) {
-        return [];
-    }
-    const results = new Array(items.length);
-    const workerCount = Math.min(items.length, Math.max(1, limit));
-    let nextIndex = 0;
-    const workers = Array.from({ length: workerCount }, async () => {
-        while (true) {
-            const currentIndex = nextIndex;
-            nextIndex += 1;
-            if (currentIndex >= items.length) {
-                return;
-            }
-            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
-        }
-    });
-    await Promise.all(workers);
-    return results;
-}
 async function loadRowsForIDLoader(options, ids, context) {
     let col = options.key;
     const typ = options.keyType || "uuid";
@@ -117,19 +94,21 @@ async function loadRowsForIDLoader(options, ids, context) {
     }
     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,
@@ -143,21 +122,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) {
+function createDataLoader(options, context) {
+    const loaderName = `objectLoader:${options.tableName}:${options.key}`;
     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);
-    }
-    return new dataloader_1.default(async (ids) => {
+    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) {
@@ -171,7 +148,7 @@ class clauseCacheMap {
         if (ret) {
             (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key2 + (this.count ? ":count" : ""),
-                "tableName": this.options.tableName,
+                tableName: this.options.tableName,
             });
         }
         return ret;
@@ -186,27 +163,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 [];
         }
-        return mapWithConcurrency(clauses, clauseLoaderConcurrency, (clauseItem) => loadRowsForClauseLoader(options, clauseItem));
+        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 [];
         }
-        return mapWithConcurrency(clauses, clauseLoaderConcurrency, (clauseItem) => loadCountForClauseLoader(options, clauseItem));
+        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) {
@@ -217,10 +199,10 @@ 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));
+        this.memoizedInitPrime = (0, memoize_1.memoizeNoArgs)(this.initPrime.bind(this));
     }
     getOptions() {
         return this.options;
@@ -273,7 +255,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();
@@ -300,7 +282,7 @@ class ObjectLoader {
             // @ts-expect-error TODO?
             return this.clauseLoader.loadMany(keys);
         }
-        return mapWithConcurrency(keys, clauseLoaderConcurrency, (key) => loadRowsForClauseLoader(this.options, key));
+        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
@@ -329,7 +311,7 @@ class ObjectCountLoader {
         this.options = options;
         this.context = context;
         if (context) {
-            this.loader = createClauseCountDataLoader(options);
+            this.loader = createClauseCountDataLoader(options, context);
         }
     }
     getOptions() {
@@ -339,7 +321,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();
@@ -352,7 +334,7 @@ class ObjectCountLoader {
             // @ts-expect-error
             return this.loader.loadMany(keys);
         }
-        return mapWithConcurrency(keys, clauseLoaderConcurrency, (key) => loadCountForClauseLoader(this.options, key));
+        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

@@ -1,4 +1,4 @@
-import { Context, Data, EdgeQueryableDataOptions, Loader, LoaderFactory } from "../base";
+import { Context, Data, EdgeQueryableDataOptions, Loader, LoaderFactory, SelectBaseDataOptions } from "../base";
 import * as clause from "../clause";
 import { OrderBy } from "../query_impl";
 import { ObjectLoaderFactory } from "./object_loader";
@@ -14,10 +14,7 @@ declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     clearAll(): void;
 }
 interface QueryOptions {
-    fields: (string | {
-        alias: string;
-        column: string;
-    })[];
+    fields: SelectBaseDataOptions["fields"];
     tableName: string;
     groupCol?: string;
     clause?: clause.Clause;

package/core/loaders/query_loader.js

@@ -32,17 +32,12 @@ 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.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 memoize_1 = require("../memoize");
+const query_impl_1 = require("../query_impl");
 const loader_1 = require("./loader");
 function getOrderByLocal(options, queryOptions) {
     return (options.orderby ??
@@ -53,7 +48,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);
@@ -76,24 +71,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) {
+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),
     };
-    // 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) => {
+    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();
@@ -104,6 +102,10 @@ function createLoader(options, queryOptions) {
             m.set(keys[i], i);
         }
         const col = options.groupCol;
+        const effectiveOrderBy = getOrderByLocal(options, queryOptions);
+        if ((0, query_impl_1.orderByHasExpressions)(effectiveOrderBy)) {
+            throw new Error("grouped query loaders do not support computed order expressions");
+        }
         let extraClause;
         if (options.clause && queryOptions?.clause) {
             extraClause = clause.And(options.clause, queryOptions.clause);
@@ -118,7 +120,7 @@ function createLoader(options, queryOptions) {
             tableName: options.tableName,
             fields: options.fields,
             values: keys,
-            orderby: getOrderByLocal(options, queryOptions),
+            orderby: effectiveOrderBy,
             limit: queryOptions?.limit || (0, ent_1.getDefaultLimit)(),
             groupColumn: col,
             clause: extraClause,
@@ -134,14 +136,14 @@ function createLoader(options, queryOptions) {
             result[idx].push(row);
         }
         return result;
-    }, loaderOptions);
+    }, loaderOptions, options.tableName);
 }
 class QueryDirectLoader {
     constructor(options, queryOptions, context) {
         this.options = options;
         this.queryOptions = queryOptions;
         this.context = context;
-        this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
+        this.memoizedInitPrime = (0, memoize_1.memoizeNoArgs)(this.initPrime.bind(this));
     }
     initPrime() {
         if (!this.context || !this.options?.toPrime) {
@@ -158,7 +160,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) {
@@ -184,9 +186,9 @@ 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));
+        this.memoizedInitPrime = (0, memoize_1.memoizeNoArgs)(this.initPrime.bind(this));
     }
     initPrime() {
         if (!this.context || !this.options?.toPrime) {
@@ -218,7 +220,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();
@@ -244,13 +246,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);
         }
+        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, query_impl_1.getOrderByKey)(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}`;
+        const key = `${name}:limit:${effectiveLimit}:orderby:${(0, query_impl_1.getOrderByKey)(effectiveOrderBy)}:disableTransformations:${disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(queryOptions, context, options), context);
     }
 }

package/core/loaders/raw_count_loader.d.ts

@@ -1,13 +1,13 @@
-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 | undefined;