@snowtop/ent 0.2.4 → 0.2.6

package/core/loaders/assoc_count_loader.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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/core/loaders/assoc_edge_loader.d.ts

@@ -22,8 +22,8 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeType;
     private edgeCtr;
     private options?;
-    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    context?: Context | undefined;
+    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: EdgeQueryableDataOptions | undefined, context?: Context | undefined);
     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

@@ -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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -32,9 +42,28 @@ 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 getDefaultOrderBy() {
+    return [
+        {
+            column: "time",
+            direction: "DESC",
+        },
+    ];
+}
+function getEffectiveOptions(options) {
+    return {
+        ...options,
+        orderby: options.orderby ?? getDefaultOrderBy(),
+        limit: options.limit || (0, ent_1.getDefaultLimit)(),
+        disableTransformations: options.disableTransformations ?? false,
+    };
+}
 function createLoader(options, edgeType, edgeCtr, edgeData) {
-    const loaderOptions = {};
+    const loaderOptions = {
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+    };
     if ((0, logger_1.logEnabled)("query")) {
         loaderOptions.cacheMap = new loader_1.CacheMap({
             tableName: edgeData.edgeTable,
@@ -59,14 +88,9 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
             // store the index....
             m.set(keys[i], i);
         }
-        options.orderby = options.orderby || [
-            {
-                column: "time",
-                direction: "DESC",
-            },
-        ];
+        const orderby = options.orderby ?? getDefaultOrderBy();
         // TODO defaultEdgeQueryOptions
-        options.limit = options.limit || (0, ent_1.getDefaultLimit)();
+        const limit = options.limit || (0, ent_1.getDefaultLimit)();
         const tableName = edgeData.edgeTable;
         const { cls: cls1, fields } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", edgeType), {
             queryOptions: options,
@@ -75,8 +99,8 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
             tableName: tableName,
             fields,
             values: keys,
-            orderby: options.orderby,
-            limit: options.limit || (0, ent_1.getDefaultLimit)(),
+            orderby,
+            limit,
             groupColumn: "id1",
             clause: cls1,
         });
@@ -207,9 +231,9 @@ class AssocEdgeLoaderFactory {
         if (options?.clause || !context) {
             return new AssocDirectEdgeLoader(this.edgeType, edgeCtr, options, context);
         }
-        // we create a loader which can combine first X queries in the same fetch
-        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby?.map((orderBy) => JSON.stringify(orderBy))}:disableTransformations:${options.disableTransformations}`;
-        return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeLoader(this.edgeType, ctr, options, context), context);
+        const effectiveOptions = getEffectiveOptions(options);
+        const key = `${this.name}:limit:${effectiveOptions.limit}:orderby:${(0, cache_utils_1.stableStringify)(effectiveOptions.orderby)}:disableTransformations:${effectiveOptions.disableTransformations}`;
+        return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeLoader(this.edgeType, ctr, effectiveOptions, context), context);
     }
 }
 exports.AssocEdgeLoaderFactory = AssocEdgeLoaderFactory;

package/core/loaders/cache_utils.d.ts

@@ -0,0 +1 @@
+export declare function stableStringify(value: unknown): string;

package/core/loaders/cache_utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableStringify = stableStringify;
+function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function normalizeForStableStringify(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeForStableStringify(item));
+    }
+    if (isPlainObject(value)) {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = normalizeForStableStringify(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+function stableStringify(value) {
+    const normalized = normalizeForStableStringify(value);
+    const result = JSON.stringify(normalized);
+    return result === undefined ? "undefined" : result;
+}

package/core/loaders/index.d.ts

@@ -3,3 +3,4 @@ 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";

package/core/loaders/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
+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;
 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; } });
@@ -16,3 +16,6 @@ Object.defineProperty(exports, "AssocEdgeLoader", { enumerable: true, get: funct
 Object.defineProperty(exports, "AssocEdgeLoaderFactory", { enumerable: true, get: function () { return assoc_edge_loader_1.AssocEdgeLoaderFactory; } });
 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, "getLoaderMaxBatchSize", { enumerable: true, get: function () { return loader_1.getLoaderMaxBatchSize; } });
+Object.defineProperty(exports, "setLoaderMaxBatchSize", { enumerable: true, get: function () { return loader_1.setLoaderMaxBatchSize; } });

package/core/loaders/loader.d.ts

@@ -1,4 +1,6 @@
 import { Loader, LoaderFactory, Context, DataOptions } from "../base";
+export declare function getLoaderMaxBatchSize(): number;
+export declare function setLoaderMaxBatchSize(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 declare class CacheMap {

package/core/loaders/loader.js

@@ -1,7 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheMap = exports.getCustomLoader = exports.getLoader = void 0;
+exports.CacheMap = void 0;
+exports.getLoaderMaxBatchSize = getLoaderMaxBatchSize;
+exports.setLoaderMaxBatchSize = setLoaderMaxBatchSize;
+exports.getLoader = getLoader;
+exports.getCustomLoader = getCustomLoader;
 const logger_1 = require("../logger");
+const DEFAULT_MAX_BATCH_SIZE = 1000;
+let loaderMaxBatchSize = DEFAULT_MAX_BATCH_SIZE;
+function getLoaderMaxBatchSize() {
+    return loaderMaxBatchSize;
+}
+function setLoaderMaxBatchSize(size) {
+    if (size === undefined || size === null) {
+        loaderMaxBatchSize = DEFAULT_MAX_BATCH_SIZE;
+        return;
+    }
+    if (!Number.isFinite(size) || size <= 0) {
+        throw new Error(`maxBatchSize must be a positive number`);
+    }
+    loaderMaxBatchSize = 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
@@ -14,7 +33,6 @@ function getLoader(factory, create, context) {
     // g|set from context cache
     return context.cache.getLoader(factory.name, create);
 }
-exports.getLoader = getLoader;
 function getCustomLoader(key, create, context) {
     // just create a new one every time if no context cache
     if (!context?.cache) {
@@ -24,7 +42,6 @@ function getCustomLoader(key, create, context) {
     // g|set from context cache
     return context.cache.getLoader(key, create);
 }
-exports.getCustomLoader = getCustomLoader;
 class CacheMap {
     constructor(options) {
         this.options = options;

package/core/loaders/object_loader.d.ts

@@ -1,14 +1,16 @@
 import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
 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 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<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    context?: Context | undefined;
     private toPrime?;
     private idLoader;
     private clauseLoader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<TResultData>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context | undefined, toPrime?: ObjectLoaderFactory<TResultData>[] | undefined);
     getOptions(): SelectDataOptions;
     private initPrime;
     load(key: ID): Promise<TResultData | null>;
@@ -25,9 +27,9 @@ export declare class ObjectLoader<TQueryData extends Data = Data, TResultData ex
 }
 export declare class ObjectCountLoader<V extends Data = Data, K = keyof V> implements Loader<clause.Clause<V, K>, number> {
     private options;
-    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    context?: Context | undefined;
     private loader;
-    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(options: SelectDataOptions, context?: Context | undefined);
     getOptions(): SelectDataOptions;
     load(key: clause.Clause<V, K>): Promise<number>;
     clearAll(): void;

package/core/loaders/object_loader.js

@@ -15,18 +15,30 @@ 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;
+exports.setClauseLoaderConcurrency = setClauseLoaderConcurrency;
+exports.mapWithConcurrency = mapWithConcurrency;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
@@ -34,14 +46,48 @@ 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 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 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,17 +95,25 @@ 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;
 }
@@ -90,7 +144,9 @@ async function loadCountForClauseLoader(options, 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 = {};
+    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);
@@ -135,14 +191,10 @@ function createClauseDataLoder(options) {
         if (!clauses.length) {
             return [];
         }
-        const ret = [];
-        for await (const clause of clauses) {
-            const data = await loadRowsForClauseLoader(options, clause);
-            ret.push(data);
-        }
-        return ret;
+        return mapWithConcurrency(clauses, clauseLoaderConcurrency, (clauseItem) => loadRowsForClauseLoader(options, clauseItem));
     }, {
         cacheMap: new clauseCacheMap(options),
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
     });
 }
 function createClauseCountDataLoader(options) {
@@ -150,14 +202,10 @@ function createClauseCountDataLoader(options) {
         if (!clauses.length) {
             return [];
         }
-        const ret = [];
-        for await (const clause of clauses) {
-            const data = await loadCountForClauseLoader(options, clause);
-            ret.push(data);
-        }
-        return ret;
+        return mapWithConcurrency(clauses, clauseLoaderConcurrency, (clauseItem) => loadCountForClauseLoader(options, clauseItem));
     }, {
         cacheMap: new clauseCacheMap(options, true),
+        maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
     });
 }
 class ObjectLoader {
@@ -252,12 +300,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 mapWithConcurrency(keys, clauseLoaderConcurrency, (key) => loadRowsForClauseLoader(this.options, key));
     }
     prime(data) {
         // we have this data from somewhere else, prime it in the c
@@ -309,12 +352,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 mapWithConcurrency(keys, clauseLoaderConcurrency, (key) => loadCountForClauseLoader(this.options, key));
     }
 }
 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,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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -32,6 +42,7 @@ 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 ??
@@ -68,7 +79,9 @@ async function simpleCase(options, id, queryOptions) {
     });
 }
 function createLoader(options, queryOptions) {
-    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);
@@ -234,7 +247,10 @@ class QueryLoaderFactory {
         if (options.clause || !context) {
             return new QueryDirectLoader(queryOptions, options, context);
         }
-        const key = `${name}:limit:${options.limit}:orderby:${options.orderby}`;
+        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

@@ -10,9 +10,9 @@ interface QueryCountOptions {
 export declare function createCountDataLoader<K extends any>(options: QueryCountOptions): DataLoader<K, number, K>;
 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,18 +15,29 @@ 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.RawCountLoaderFactory = exports.RawCountLoader = exports.createCountDataLoader = void 0;
+exports.RawCountLoaderFactory = exports.RawCountLoader = void 0;
+exports.createCountDataLoader = createCountDataLoader;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
@@ -56,7 +67,9 @@ async function simpleCase(options, key, context) {
     return [parseInt(row?.count, 10) || 0];
 }
 function createCountDataLoader(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);
@@ -99,7 +112,6 @@ function createCountDataLoader(options) {
         return result;
     }, loaderOptions);
 }
-exports.createCountDataLoader = createCountDataLoader;
 // for now this only works for single column counts
 // e.g. foreign key count
 class RawCountLoader {