@graphql-mesh/urql-exchange/index.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

const wonka = require('wonka');
const core = require('@urql/core');
const utils = require('@graphql-tools/utils');

const ROOT_VALUE = {};
const makeExecuteSource = (operation, options) => {
    const operationFn = operation.kind === 'subscription' ? options.subscribe : options.execute;
    const operationName = core.getOperationName(operation.query);
    return wonka.make(observer => {
        let ended = false;
        operationFn(operation.query, operation.variables, operation.context, ROOT_VALUE, operationName)
            .then((result) => {
            if (ended || !result) {
                return;
            }
            else if (!utils.isAsyncIterable(result)) {
                observer.next(core.makeResult(operation, result));
                return;
            }
            const iterator = result[Symbol.asyncIterator]();
            let prevResult = null;
            function next({ done, value }) {
                if (value) {
                    observer.next((prevResult = prevResult ? core.mergeResultPatch(prevResult, value) : core.makeResult(operation, value)));
                }
                if (!done && !ended) {
                    return iterator.next().then(next);
                }
                if (ended && iterator.return != null) {
                    return iterator.return();
                }
            }
            return iterator.next().then(next);
        })
            .then(() => {
            observer.complete();
        })
            .catch(error => {
            observer.next(core.makeErrorResult(operation, error));
            observer.complete();
        });
        return () => {
            ended = true;
        };
    });
};
/** Exchange for executing queries locally on a schema using graphql-js. */
const meshExchange = (options) => ({ forward }) => {
    return ops$ => {
        const sharedOps$ = wonka.share(ops$);
        const executedOps$ = wonka.pipe(sharedOps$, wonka.filter((operation) => {
            return operation.kind === 'query' || operation.kind === 'mutation' || operation.kind === 'subscription';
        }), wonka.mergeMap((operation) => {
            const { key } = operation;
            const teardown$ = wonka.pipe(sharedOps$, wonka.filter(op => op.kind === 'teardown' && op.key === key));
            return wonka.pipe(makeExecuteSource(operation, options), wonka.takeUntil(teardown$));
        }));
        const forwardedOps$ = wonka.pipe(sharedOps$, wonka.filter(operation => operation.kind === 'teardown'), forward);
        return wonka.merge([executedOps$, forwardedOps$]);
    };
};

exports.meshExchange = meshExchange;