@connected/client/dist/rpc-transfer.js

The hassle free way to call your server-side code

import find from 'array-find';
import uuid from 'uuid/v4.js';
import DataLoader from 'dataloader';
import JaysonBrowserClient from 'jayson/lib/client/browser/index.js';
import RpcError from './rpc-error.js';
function calculateClientResponse(resolve, err, errors, results) {
    resolve({ err, errors, successes: results });
}
export default class RpcTransfer {
    rpcClient;
    dataLoaderMap = new Map();
    constructor(urlOrOptions) {
        let url = '/rpc';
        let headers = {};
        if (typeof urlOrOptions === 'string') {
            url = urlOrOptions;
        }
        else if (typeof urlOrOptions === 'object') {
            url = urlOrOptions.url ?? url;
            headers = urlOrOptions.headers ?? {};
        }
        function serverRequester(request, callback) {
            const options = {
                method: 'POST',
                body: request,
                headers: {
                    'Content-Type': 'application/json',
                    ...headers,
                },
            };
            fetch(url, options)
                .then((res) => res.text())
                .then((text) => callback(null, text))
                .catch((error) => callback(error));
        }
        this.rpcClient = new JaysonBrowserClient(serverRequester, {});
    }
    findDataLoader(group = 'default') {
        if (this.dataLoaderMap.has(group)) {
            return this.dataLoaderMap.get(group);
        }
        const dataLoader = new DataLoader((requests) => this.batchRequest(requests), { cacheKeyFn: (key) => key.id });
        this.dataLoaderMap.set(group, dataLoader);
        return dataLoader;
    }
    request(procName, params, group) {
        return this.findDataLoader(group).load(this.rpcClient.request(procName, params, uuid()));
    }
    batchRequest(requests) {
        return new Promise((resolve) => {
            const callback = calculateClientResponse.bind(null, resolve);
            this.rpcClient.request(requests, callback);
        }).then(({ err, errors, successes, }) => {
            if (err) {
                return requests.map(() => err);
            }
            return requests.map((request) => {
                const errorResult = find(errors, (error) => !!error && error.id === request.id);
                if (errorResult) {
                    return new RpcError(errorResult.error);
                }
                const success = find(successes, (s) => !!s && s.id === request.id);
                if (success) {
                    return success.result;
                }
                return new Error('Message id missing in the response');
            });
        });
    }
}
//# sourceMappingURL=rpc-transfer.js.map