@graphql-tools/batch-delegate/index.mjs

import { GraphQLList, getNamedType } from 'graphql';
import DataLoader from 'dataloader';
import { delegateToSchema } from '@graphql-tools/delegate';
import { relocatedError } from '@graphql-tools/utils';

const cache1 = new WeakMap();
function createBatchFn(options) {
    var _a, _b;
    const argsFromKeys = (_a = options.argsFromKeys) !== null && _a !== void 0 ? _a : ((keys) => ({ ids: keys }));
    const fieldName = (_b = options.fieldName) !== null && _b !== void 0 ? _b : options.info.fieldName;
    const { valuesFromResults, lazyOptionsFn } = options;
    return async (keys) => {
        const results = await delegateToSchema({
            returnType: new GraphQLList(getNamedType(options.info.returnType)),
            onLocatedError: originalError => {
                if (originalError.path == null) {
                    return originalError;
                }
                const [pathFieldName, pathNumber] = originalError.path;
                if (pathFieldName !== fieldName) {
                    return originalError;
                }
                const pathNumberType = typeof pathNumber;
                if (pathNumberType !== 'number') {
                    return originalError;
                }
                return relocatedError(originalError, originalError.path.slice(0, 0).concat(originalError.path.slice(2)));
            },
            args: argsFromKeys(keys),
            ...(lazyOptionsFn == null ? options : lazyOptionsFn(options)),
        });
        if (results instanceof Error) {
            return keys.map(() => results);
        }
        const values = valuesFromResults == null ? results : valuesFromResults(results, keys);
        return Array.isArray(values) ? values : keys.map(() => values);
    };
}
const cacheKeyFn = (key) => (typeof key === 'object' ? JSON.stringify(key) : key);
function getLoader(options) {
    var _a;
    const fieldName = (_a = options.fieldName) !== null && _a !== void 0 ? _a : options.info.fieldName;
    let cache2 = cache1.get(options.info.fieldNodes);
    // Prevents the keys to be passed with the same structure
    const dataLoaderOptions = {
        cacheKeyFn,
        ...options.dataLoaderOptions,
    };
    if (cache2 === undefined) {
        cache2 = new WeakMap();
        cache1.set(options.info.fieldNodes, cache2);
        const loaders = Object.create(null);
        cache2.set(options.schema, loaders);
        const batchFn = createBatchFn(options);
        const loader = new DataLoader(keys => batchFn(keys), dataLoaderOptions);
        loaders[fieldName] = loader;
        return loader;
    }
    let loaders = cache2.get(options.schema);
    if (loaders === undefined) {
        loaders = Object.create(null);
        cache2.set(options.schema, loaders);
        const batchFn = createBatchFn(options);
        const loader = new DataLoader(keys => batchFn(keys), dataLoaderOptions);
        loaders[fieldName] = loader;
        return loader;
    }
    let loader = loaders[fieldName];
    if (loader === undefined) {
        const batchFn = createBatchFn(options);
        loader = new DataLoader(keys => batchFn(keys), dataLoaderOptions);
        loaders[fieldName] = loader;
    }
    return loader;
}

function batchDelegateToSchema(options) {
    const key = options.key;
    if (key == null) {
        return null;
    }
    else if (Array.isArray(key) && !key.length) {
        return [];
    }
    const loader = getLoader(options);
    return Array.isArray(key) ? loader.loadMany(key) : loader.load(key);
}

function createBatchDelegateFn(optionsOrArgsFromKeys, lazyOptionsFn, dataLoaderOptions, valuesFromResults) {
    return typeof optionsOrArgsFromKeys === 'function'
        ? createBatchDelegateFnImpl({
            argsFromKeys: optionsOrArgsFromKeys,
            lazyOptionsFn,
            dataLoaderOptions,
            valuesFromResults,
        })
        : createBatchDelegateFnImpl(optionsOrArgsFromKeys);
}
function createBatchDelegateFnImpl(options) {
    return batchDelegateOptions => {
        const loader = getLoader({
            ...options,
            ...batchDelegateOptions,
        });
        return loader.load(batchDelegateOptions.key);
    };
}

export { batchDelegateToSchema, createBatchDelegateFn };