@snowtop/ent 0.2.6 → 0.2.8

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;
@@ -71,6 +68,7 @@ exports.editRow = editRow;
 exports.editRowSync = editRowSync;
 exports.deleteRows = deleteRows;
 exports.deleteRowsSync = deleteRowsSync;
+exports.decodeCursorPayload = decodeCursorPayload;
 exports.getCursor = getCursor;
 exports.loadEdgeData = loadEdgeData;
 exports.loadEdgeDatas = loadEdgeDatas;
@@ -90,7 +88,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 +123,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 +151,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 +173,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 +210,7 @@ function createEntLoader(viewer, options, map) {
             }
             return r;
         });
-    }, loaderOptions);
+    }, loaderOptions, tableName);
 }
 class EntLoader {
     constructor(viewer, options) {
@@ -637,13 +608,13 @@ async function loadRow(options) {
             return row;
         }
     }
-    const query = (0, query_impl_1.buildQuery)(options);
-    logQuery(query, options.clause.logValues());
+    const queryData = (0, query_impl_1.buildQueryData)(options);
+    logQuery(queryData.query, queryData.logValues);
     const pool = db_1.default.getInstance().getPool();
-    const res = await pool.query(query, options.clause.values());
+    const res = await pool.query(queryData.query, queryData.values);
     if (res.rowCount != 1) {
         if (res.rowCount > 1) {
-            (0, logger_1.log)("error", "got more than one row for query " + query);
+            (0, logger_1.log)("error", "got more than one row for query " + queryData.query);
         }
         return null;
     }
@@ -682,8 +653,8 @@ async function loadRows(options) {
             return rows;
         }
     }
-    const query = (0, query_impl_1.buildQuery)(options);
-    const r = await performRawQuery(query, options.clause.values(), options.clause.logValues());
+    const queryData = (0, query_impl_1.buildQueryData)(options);
+    const r = await performRawQuery(queryData.query, queryData.values, queryData.logValues);
     if (cache) {
         // put the rows in the cache...
         cache.primeCache(options, r);
@@ -692,6 +663,12 @@ async function loadRows(options) {
 }
 // this is used for queries when we select multiple ids at once
 function buildGroupQuery(options) {
+    if (options.fields.some((field) => typeof field === "object" && "expression" in field)) {
+        throw new Error("group queries do not support computed select expressions");
+    }
+    if (options.orderby && (0, query_impl_1.orderByHasExpressions)(options.orderby)) {
+        throw new Error("group queries do not support computed order expressions");
+    }
     const fields = [...options.fields, "row_number()"];
     let cls = clause.In(options.groupColumn, ...options.values);
     if (options.clause) {
@@ -930,6 +907,14 @@ class AssocEdge {
     }
 }
 exports.AssocEdge = AssocEdge;
+// UTF-8-safe cursor encoding (btoa only supports Latin-1 code units).
+function encodeCursorPayload(json) {
+    return Buffer.from(json, "utf8").toString("base64");
+}
+// Inverse of encodeCursorPayload; exported for pagination decode in query.ts
+function decodeCursorPayload(encoded) {
+    return Buffer.from(encoded, "base64").toString("utf8");
+}
 // TODO eventually update this for sortCol time unique keys
 function getCursor(opts) {
     const { row, cursorKeys, rowKeys } = opts;
@@ -947,7 +932,7 @@ function getCursor(opts) {
         const rowKey = rowKeys?.[i] || cursorKey;
         parts.push([cursorKey, convert(row[rowKey])]);
     }
-    return btoa(JSON.stringify(parts));
+    return encodeCursorPayload(JSON.stringify(parts));
 }
 class AssocEdgeData {
     constructor(data) {

package/core/extensions.d.ts

@@ -0,0 +1,25 @@
+import { type Pool } from "pg";
+import type { RuntimeDBExtension } from "./config";
+import type { ResolvedDevSchema } from "./dev_schema";
+export interface InstalledDBExtension {
+    name: string;
+    version: string;
+    installSchema?: string;
+}
+export interface ExtensionTypeParser {
+    name: string;
+    parse(value: string | null): unknown;
+}
+export interface ExtensionRuntimeHandler {
+    name: string;
+    runtimeSchemas?: string[];
+    types?: ExtensionTypeParser[];
+    validate?(installed: InstalledDBExtension, extension: RuntimeDBExtension): void | Promise<void>;
+}
+export declare function registerExtensionRuntime(handler: ExtensionRuntimeHandler): void;
+export declare function clearExtensionRuntimes(): void;
+export declare function normalizeExtensions(extensions: RuntimeDBExtension[]): RuntimeDBExtension[];
+export declare function resolveExtensions(cfg?: RuntimeDBExtension[]): RuntimeDBExtension[];
+export declare function getExtensionSearchPathSchemas(extensions: RuntimeDBExtension[]): string[];
+export declare function buildExtensionSearchPath(resolvedDevSchema: ResolvedDevSchema, extensions: RuntimeDBExtension[]): string | undefined;
+export declare function initializeExtensions(pool: Pick<Pool, "query">, extensions: RuntimeDBExtension[]): Promise<void>;

package/core/extensions.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerExtensionRuntime = registerExtensionRuntime;
+exports.clearExtensionRuntimes = clearExtensionRuntimes;
+exports.normalizeExtensions = normalizeExtensions;
+exports.resolveExtensions = resolveExtensions;
+exports.getExtensionSearchPathSchemas = getExtensionSearchPathSchemas;
+exports.buildExtensionSearchPath = buildExtensionSearchPath;
+exports.initializeExtensions = initializeExtensions;
+const pg_1 = require("pg");
+const TEXT_ARRAY_OID = 1009;
+const runtimeHandlers = new Map();
+const registeredTypeOIDs = new Set();
+function normalizeProvisionedBy(extension) {
+    if (extension.provisionedBy === "ent" ||
+        extension.provisionedBy === "external") {
+        return extension.provisionedBy;
+    }
+    if (extension.provisionedBy) {
+        throw new Error(`invalid provisionedBy ${extension.provisionedBy} for db extension ${extension.name}`);
+    }
+    return "ent";
+}
+function normalizeRuntimeHandler(handler) {
+    const typeHandlers = new Map();
+    for (const typeHandler of handler.types || []) {
+        typeHandlers.set(typeHandler.name, typeHandler);
+    }
+    return {
+        ...handler,
+        runtimeSchemas: [...new Set(handler.runtimeSchemas || [])],
+        types: [...typeHandlers.values()],
+    };
+}
+function mergeRuntimeHandlers(lhs, rhs) {
+    const mergedTypes = new Map();
+    for (const typeHandler of lhs.types || []) {
+        mergedTypes.set(typeHandler.name, typeHandler);
+    }
+    for (const typeHandler of rhs.types || []) {
+        mergedTypes.set(typeHandler.name, typeHandler);
+    }
+    return {
+        name: rhs.name,
+        runtimeSchemas: [
+            ...new Set([
+                ...(lhs.runtimeSchemas || []),
+                ...(rhs.runtimeSchemas || []),
+            ]),
+        ],
+        types: [...mergedTypes.values()],
+        validate: rhs.validate || lhs.validate,
+    };
+}
+function getRegisteredRuntimeHandlers() {
+    return [...runtimeHandlers.values()].sort((lhs, rhs) => lhs.name.localeCompare(rhs.name));
+}
+function registerExtensionRuntime(handler) {
+    const normalized = normalizeRuntimeHandler(handler);
+    const existing = runtimeHandlers.get(normalized.name);
+    runtimeHandlers.set(normalized.name, existing ? mergeRuntimeHandlers(existing, normalized) : normalized);
+}
+function clearExtensionRuntimes() {
+    runtimeHandlers.clear();
+    registeredTypeOIDs.clear();
+}
+function normalizeExtensions(extensions) {
+    return [...extensions]
+        .map((extension) => ({
+        ...extension,
+        provisionedBy: normalizeProvisionedBy(extension),
+        runtimeSchemas: extension.runtimeSchemas || [],
+        dropCascade: extension.dropCascade === true,
+    }))
+        .sort((lhs, rhs) => lhs.name.localeCompare(rhs.name));
+}
+function resolveExtensions(cfg) {
+    return normalizeExtensions(cfg || []);
+}
+function getExtensionSearchPathSchemas(extensions) {
+    const normalizedExtensions = normalizeExtensions(extensions);
+    const configuredExtensions = new Map(normalizedExtensions.map((extension) => [extension.name, extension]));
+    const seen = new Set();
+    const schemas = [];
+    function addSchemas(runtimeSchemas) {
+        for (const schema of runtimeSchemas) {
+            if (!schema || seen.has(schema)) {
+                continue;
+            }
+            seen.add(schema);
+            schemas.push(schema);
+        }
+    }
+    for (const extension of normalizedExtensions) {
+        addSchemas(extension.runtimeSchemas || []);
+    }
+    for (const handler of getRegisteredRuntimeHandlers()) {
+        const configured = configuredExtensions.get(handler.name);
+        addSchemas(configured
+            ? configured.runtimeSchemas || []
+            : handler.runtimeSchemas || []);
+    }
+    return schemas;
+}
+function buildExtensionSearchPath(resolvedDevSchema, extensions) {
+    const schemas = [];
+    if (resolvedDevSchema.enabled && resolvedDevSchema.schemaName) {
+        schemas.push(resolvedDevSchema.schemaName);
+    }
+    for (const schema of getExtensionSearchPathSchemas(extensions)) {
+        if (!schemas.includes(schema)) {
+            schemas.push(schema);
+        }
+    }
+    if (resolvedDevSchema.enabled &&
+        resolvedDevSchema.includePublic &&
+        !schemas.includes("public")) {
+        schemas.push("public");
+    }
+    if (!resolvedDevSchema.enabled &&
+        schemas.length > 0 &&
+        !schemas.includes("public")) {
+        schemas.push("public");
+    }
+    if (schemas.length === 0) {
+        return undefined;
+    }
+    return schemas.join(",");
+}
+async function getInstalledExtensions(pool, extensions) {
+    if (extensions.length === 0) {
+        return new Map();
+    }
+    const res = await pool.query(`
+      SELECT
+        extname,
+        extversion,
+        extnamespace::regnamespace::text AS install_schema
+      FROM pg_extension
+      WHERE extname = ANY($1::text[])
+    `, [extensions.map((extension) => extension.name)]);
+    const installed = new Map();
+    for (const row of res.rows) {
+        installed.set(row.extname, {
+            name: row.extname,
+            version: row.extversion,
+            installSchema: row.install_schema,
+        });
+    }
+    return installed;
+}
+function registerArrayParser(arrayOID, parse) {
+    if (!arrayOID || registeredTypeOIDs.has(arrayOID)) {
+        return;
+    }
+    const parseTextArray = pg_1.types.getTypeParser(TEXT_ARRAY_OID);
+    pg_1.types.setTypeParser(arrayOID, (value) => {
+        if (value === null) {
+            return null;
+        }
+        const parsed = parseTextArray(value);
+        return parsed.map((entry) => parse(entry));
+    });
+    registeredTypeOIDs.add(arrayOID);
+}
+async function initializeRegisteredTypeParsers(pool, configuredExtensions) {
+    const registeredTypes = new Map();
+    for (const handler of getRegisteredRuntimeHandlers()) {
+        for (const typeHandler of handler.types || []) {
+            registeredTypes.set(typeHandler.name, {
+                extensionName: handler.name,
+                parse: typeHandler.parse,
+            });
+        }
+    }
+    if (registeredTypes.size === 0) {
+        return;
+    }
+    const res = await pool.query(`
+      SELECT oid, typname, typarray
+      FROM pg_type
+      WHERE typname = ANY($1::text[])
+    `, [[...registeredTypes.keys()]]);
+    const rowsByType = new Map(res.rows.map((row) => [row.typname, row]));
+    for (const [typeName, typeHandler] of registeredTypes.entries()) {
+        const row = rowsByType.get(typeName);
+        if (!row) {
+            if (configuredExtensions.has(typeHandler.extensionName)) {
+                throw new Error(`required pg type "${typeName}" for db extension "${typeHandler.extensionName}" was not found`);
+            }
+            continue;
+        }
+        if (!registeredTypeOIDs.has(row.oid)) {
+            pg_1.types.setTypeParser(row.oid, typeHandler.parse);
+            registeredTypeOIDs.add(row.oid);
+        }
+        registerArrayParser(row.typarray, typeHandler.parse);
+    }
+}
+async function initializeExtensions(pool, extensions) {
+    const normalizedExtensions = normalizeExtensions(extensions);
+    const configuredExtensions = new Map(normalizedExtensions.map((extension) => [extension.name, extension]));
+    const installedExtensions = await getInstalledExtensions(pool, normalizedExtensions);
+    for (const extension of normalizedExtensions) {
+        const installed = installedExtensions.get(extension.name);
+        if (!installed) {
+            throw new Error(`required db extension "${extension.name}" is not installed`);
+        }
+        if (extension.version && extension.version !== installed.version) {
+            throw new Error(`required db extension "${extension.name}" version "${extension.version}" but found "${installed.version}"`);
+        }
+        if (extension.installSchema &&
+            extension.installSchema !== installed.installSchema) {
+            throw new Error(`required db extension "${extension.name}" install schema "${extension.installSchema}" but found "${installed.installSchema}"`);
+        }
+        const handler = runtimeHandlers.get(extension.name);
+        await handler?.validate?.(installed, extension);
+    }
+    await initializeRegisteredTypeParsers(pool, configuredExtensions);
+}

package/core/loaders/assoc_count_loader.js

@@ -32,23 +32,20 @@ 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.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = void 0;
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const loader_1 = require("./loader");
 const raw_count_loader_1 = require("./raw_count_loader");
-const memoizee_1 = __importDefault(require("memoizee"));
+const memoize_1 = require("../memoize");
 class AssocEdgeCountLoader {
     constructor(edgeType, context, options) {
         this.edgeType = edgeType;
         this.context = context;
         this.options = options;
         if (context) {
-            this.loaderFn = (0, memoizee_1.default)(this.getLoader);
+            this.loaderFn = (0, memoize_1.memoizeNoArgs)(this.getLoader.bind(this));
         }
     }
     async getLoader() {
@@ -63,7 +60,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

@@ -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.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 memoize_1 = require("../memoize");
+const query_impl_1 = require("../query_impl");
 const loader_1 = require("./loader");
 function getDefaultOrderBy() {
     return [
@@ -60,16 +55,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 +71,7 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
                 id1: keys[0],
                 edgeType: edgeType,
                 queryOptions: options,
+                context,
                 ctr: edgeCtr,
             });
             return [r];
@@ -115,7 +110,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) {
@@ -123,14 +118,14 @@ class AssocEdgeLoader {
         this.edgeCtr = edgeCtr;
         this.options = options;
         this.context = context;
-        this.loaderFn = (0, memoizee_1.default)(this.getLoader);
+        this.loaderFn = (0, memoize_1.memoizeNoArgs)(this.getLoader.bind(this));
     }
     async getLoader() {
         const edgeData = await (0, ent_1.loadEdgeData)(this.edgeType);
         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 +163,40 @@ class AssocDirectEdgeLoader {
         this.edgeCtr = edgeCtr;
         this.options = options;
         this.context = context;
+        if (this.context) {
+            this.loaderFn = (0, memoize_1.memoizeNoArgs)(this.getLoader.bind(this));
+        }
+    }
+    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 +224,9 @@ class AssocDirectEdgeLoader {
             ctr: this.edgeCtr,
         });
     }
-    clearAll() { }
+    clearAll() {
+        this.loader && this.loader.clearAll();
+    }
 }
 exports.AssocDirectEdgeLoader = AssocDirectEdgeLoader;
 class AssocEdgeLoaderFactory {
@@ -232,7 +261,7 @@ class AssocEdgeLoaderFactory {
             return new AssocDirectEdgeLoader(this.edgeType, edgeCtr, options, context);
         }
         const effectiveOptions = getEffectiveOptions(options);
-        const key = `${this.name}:limit:${effectiveOptions.limit}:orderby:${(0, cache_utils_1.stableStringify)(effectiveOptions.orderby)}:disableTransformations:${effectiveOptions.disableTransformations}`;
+        const key = `${this.name}:limit:${effectiveOptions.limit}:orderby:${(0, query_impl_1.getOrderByKey)(effectiveOptions.orderby ?? getDefaultOrderBy())}:disableTransformations:${effectiveOptions.disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeLoader(this.edgeType, ctr, effectiveOptions, context), context);
     }
 }

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