@authx/authx/dist/loader.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.QueryCache = exports.DataLoaderCache = exports.DataLoaderExecutor = void 0;
const dataloader_1 = __importDefault(require("dataloader"));
const errors_1 = require("./errors");
const object_hash_1 = __importDefault(require("object-hash"));
class DataLoaderExecutor {
    constructor(connection, strategies) {
        this.connection = connection;
        this.strategies = strategies;
    }
}
exports.DataLoaderExecutor = DataLoaderExecutor;
class DataLoaderCache {
    constructor(read) {
        this._map = new WeakMap();
        this._read = read;
    }
    get(executor) {
        let loader = this._map.get(executor);
        if (loader) {
            return loader;
        }
        const read = this._read;
        loader = new dataloader_1.default(async function (ids) {
            var _a;
            // Get the results from the read in whatever order the database found
            // most efficient.
            const results = await read(executor, ids);
            // Index the results by ID.
            const resultsById = new Map();
            for (let i = 0; i < results.length; i++) {
                const result = results[i];
                resultsById.set(result.id, result);
            }
            // Normalize the order and format to comply with the DataLoader interface.
            const returnValue = new Array(ids.length);
            for (let i = 0; i < ids.length; i++) {
                const id = ids[i];
                returnValue[i] = (_a = resultsById.get(id)) !== null && _a !== void 0 ? _a : new errors_1.NotFoundError();
            }
            return returnValue;
        });
        this._map.set(executor, loader);
        return loader;
    }
}
exports.DataLoaderCache = DataLoaderCache;
class QueryCache {
    constructor() {
        this._map = new WeakMap();
    }
    query(tx, query, parameters) {
        // Queries using a direct connection or connection pool bypass the cache.
        if (!(tx instanceof DataLoaderExecutor)) {
            return tx.query(query, parameters);
        }
        // Load a cache map keyed by the executor.
        let cache = this._map.get(tx);
        if (!cache) {
            cache = new Map();
            this._map.set(tx, cache);
        }
        // A hash of the entire query and parameters is used as the key.
        const hash = object_hash_1.default({ query, parameters });
        // Return cached results or populate the cache with new pending results.
        let result = cache.get(hash);
        if (!result) {
            result = tx.connection.query(query, parameters);
            cache.set(hash, result);
        }
        return result;
    }
}
exports.QueryCache = QueryCache;
//# sourceMappingURL=loader.js.map