@apollo/client 3.6.3 → 3.6.4

package/link/http/http.cjs.native.js

@@ -0,0 +1,320 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+var utils = require('../utils');
+var tslib = require('tslib');
+var graphql = require('graphql');
+var core = require('../core');
+var utilities = require('../../utilities');
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function parseAndCheckHttpResponse(operations) {
+    return function (response) { return response
+        .text()
+        .then(function (bodyText) {
+        try {
+            return JSON.parse(bodyText);
+        }
+        catch (err) {
+            var parseError = err;
+            parseError.name = 'ServerParseError';
+            parseError.response = response;
+            parseError.statusCode = response.status;
+            parseError.bodyText = bodyText;
+            throw parseError;
+        }
+    })
+        .then(function (result) {
+        if (response.status >= 300) {
+            utils.throwServerError(response, result, "Response not successful: Received status code ".concat(response.status));
+        }
+        if (!Array.isArray(result) &&
+            !hasOwnProperty.call(result, 'data') &&
+            !hasOwnProperty.call(result, 'errors')) {
+            utils.throwServerError(response, result, "Server response was missing for query '".concat(Array.isArray(operations)
+                ? operations.map(function (op) { return op.operationName; })
+                : operations.operationName, "'."));
+        }
+        return result;
+    }); };
+}
+
+var serializeFetchParameter = function (p, label) {
+    var serialized;
+    try {
+        serialized = JSON.stringify(p);
+    }
+    catch (e) {
+        var parseError = __DEV__ ? new globals.InvariantError("Network request failed. ".concat(label, " is not serializable: ").concat(e.message)) : new globals.InvariantError(21);
+        parseError.parseError = e;
+        throw parseError;
+    }
+    return serialized;
+};
+
+var defaultHttpOptions = {
+    includeQuery: true,
+    includeExtensions: false,
+};
+var defaultHeaders = {
+    accept: '*/*',
+    'content-type': 'application/json',
+};
+var defaultOptions = {
+    method: 'POST',
+};
+var fallbackHttpConfig = {
+    http: defaultHttpOptions,
+    headers: defaultHeaders,
+    options: defaultOptions,
+};
+var defaultPrinter = function (ast, printer) { return printer(ast); };
+function selectHttpOptionsAndBody(operation, fallbackConfig) {
+    var configs = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        configs[_i - 2] = arguments[_i];
+    }
+    configs.unshift(fallbackConfig);
+    return selectHttpOptionsAndBodyInternal.apply(void 0, tslib.__spreadArray([operation,
+        defaultPrinter], configs, false));
+}
+function selectHttpOptionsAndBodyInternal(operation, printer) {
+    var configs = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        configs[_i - 2] = arguments[_i];
+    }
+    var options = {};
+    var http = {};
+    configs.forEach(function (config) {
+        options = tslib.__assign(tslib.__assign(tslib.__assign({}, options), config.options), { headers: tslib.__assign(tslib.__assign({}, options.headers), headersToLowerCase(config.headers)) });
+        if (config.credentials) {
+            options.credentials = config.credentials;
+        }
+        http = tslib.__assign(tslib.__assign({}, http), config.http);
+    });
+    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;
+    var body = { operationName: operationName, variables: variables };
+    if (http.includeExtensions)
+        body.extensions = extensions;
+    if (http.includeQuery)
+        body.query = printer(query, graphql.print);
+    return {
+        options: options,
+        body: body,
+    };
+}
+function headersToLowerCase(headers) {
+    if (headers) {
+        var normalized_1 = Object.create(null);
+        Object.keys(Object(headers)).forEach(function (name) {
+            normalized_1[name.toLowerCase()] = headers[name];
+        });
+        return normalized_1;
+    }
+    return headers;
+}
+
+var checkFetcher = function (fetcher) {
+    if (!fetcher && typeof fetch === 'undefined') {
+        throw __DEV__ ? new globals.InvariantError("\n\"fetch\" has not been found globally and no fetcher has been configured. To fix this, install a fetch package (like https://www.npmjs.com/package/cross-fetch), instantiate the fetcher, and pass it into your HttpLink constructor. For example:\n\nimport fetch from 'cross-fetch';\nimport { ApolloClient, HttpLink } from '@apollo/client';\nconst client = new ApolloClient({\n  link: new HttpLink({ uri: '/graphql', fetch })\n});\n    ") : new globals.InvariantError(20);
+    }
+};
+
+var createSignalIfSupported = function () {
+    if (typeof AbortController === 'undefined')
+        return { controller: false, signal: false };
+    var controller = new AbortController();
+    var signal = controller.signal;
+    return { controller: controller, signal: signal };
+};
+
+var selectURI = function (operation, fallbackURI) {
+    var context = operation.getContext();
+    var contextURI = context.uri;
+    if (contextURI) {
+        return contextURI;
+    }
+    else if (typeof fallbackURI === 'function') {
+        return fallbackURI(operation);
+    }
+    else {
+        return fallbackURI || '/graphql';
+    }
+};
+
+function rewriteURIForGET(chosenURI, body) {
+    var queryParams = [];
+    var addQueryParam = function (key, value) {
+        queryParams.push("".concat(key, "=").concat(encodeURIComponent(value)));
+    };
+    if ('query' in body) {
+        addQueryParam('query', body.query);
+    }
+    if (body.operationName) {
+        addQueryParam('operationName', body.operationName);
+    }
+    if (body.variables) {
+        var serializedVariables = void 0;
+        try {
+            serializedVariables = serializeFetchParameter(body.variables, 'Variables map');
+        }
+        catch (parseError) {
+            return { parseError: parseError };
+        }
+        addQueryParam('variables', serializedVariables);
+    }
+    if (body.extensions) {
+        var serializedExtensions = void 0;
+        try {
+            serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');
+        }
+        catch (parseError) {
+            return { parseError: parseError };
+        }
+        addQueryParam('extensions', serializedExtensions);
+    }
+    var fragment = '', preFragment = chosenURI;
+    var fragmentStart = chosenURI.indexOf('#');
+    if (fragmentStart !== -1) {
+        fragment = chosenURI.substr(fragmentStart);
+        preFragment = chosenURI.substr(0, fragmentStart);
+    }
+    var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';
+    var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;
+    return { newURI: newURI };
+}
+
+var backupFetch = utilities.maybe(function () { return fetch; });
+var createHttpLink = function (linkOptions) {
+    if (linkOptions === void 0) { linkOptions = {}; }
+    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = tslib.__rest(linkOptions, ["uri", "fetch", "print", "includeExtensions", "useGETForQueries", "includeUnusedVariables"]);
+    if (__DEV__) {
+        checkFetcher(preferredFetch || backupFetch);
+    }
+    var linkConfig = {
+        http: { includeExtensions: includeExtensions },
+        options: requestOptions.fetchOptions,
+        credentials: requestOptions.credentials,
+        headers: requestOptions.headers,
+    };
+    return new core.ApolloLink(function (operation) {
+        var chosenURI = selectURI(operation, uri);
+        var context = operation.getContext();
+        var clientAwarenessHeaders = {};
+        if (context.clientAwareness) {
+            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;
+            if (name_1) {
+                clientAwarenessHeaders['apollographql-client-name'] = name_1;
+            }
+            if (version) {
+                clientAwarenessHeaders['apollographql-client-version'] = version;
+            }
+        }
+        var contextHeaders = tslib.__assign(tslib.__assign({}, clientAwarenessHeaders), context.headers);
+        var contextConfig = {
+            http: context.http,
+            options: context.fetchOptions,
+            credentials: context.credentials,
+            headers: contextHeaders,
+        };
+        var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;
+        if (body.variables && !includeUnusedVariables) {
+            var unusedNames_1 = new Set(Object.keys(body.variables));
+            graphql.visit(operation.query, {
+                Variable: function (node, _key, parent) {
+                    if (parent && parent.kind !== 'VariableDefinition') {
+                        unusedNames_1.delete(node.name.value);
+                    }
+                },
+            });
+            if (unusedNames_1.size) {
+                body.variables = tslib.__assign({}, body.variables);
+                unusedNames_1.forEach(function (name) {
+                    delete body.variables[name];
+                });
+            }
+        }
+        var controller;
+        if (!options.signal) {
+            var _c = createSignalIfSupported(), _controller = _c.controller, signal = _c.signal;
+            controller = _controller;
+            if (controller)
+                options.signal = signal;
+        }
+        var definitionIsMutation = function (d) {
+            return d.kind === 'OperationDefinition' && d.operation === 'mutation';
+        };
+        if (useGETForQueries &&
+            !operation.query.definitions.some(definitionIsMutation)) {
+            options.method = 'GET';
+        }
+        if (options.method === 'GET') {
+            var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;
+            if (parseError) {
+                return utils.fromError(parseError);
+            }
+            chosenURI = newURI;
+        }
+        else {
+            try {
+                options.body = serializeFetchParameter(body, 'Payload');
+            }
+            catch (parseError) {
+                return utils.fromError(parseError);
+            }
+        }
+        return new utilities.Observable(function (observer) {
+            var currentFetch = preferredFetch || utilities.maybe(function () { return fetch; }) || backupFetch;
+            currentFetch(chosenURI, options)
+                .then(function (response) {
+                operation.setContext({ response: response });
+                return response;
+            })
+                .then(parseAndCheckHttpResponse(operation))
+                .then(function (result) {
+                observer.next(result);
+                observer.complete();
+                return result;
+            })
+                .catch(function (err) {
+                if (err.name === 'AbortError')
+                    return;
+                if (err.result && err.result.errors && err.result.data) {
+                    observer.next(err.result);
+                }
+                observer.error(err);
+            });
+            return function () {
+                if (controller)
+                    controller.abort();
+            };
+        });
+    });
+};
+
+var HttpLink = (function (_super) {
+    tslib.__extends(HttpLink, _super);
+    function HttpLink(options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this, createHttpLink(options).request) || this;
+        _this.options = options;
+        return _this;
+    }
+    return HttpLink;
+}(core.ApolloLink));
+
+exports.HttpLink = HttpLink;
+exports.checkFetcher = checkFetcher;
+exports.createHttpLink = createHttpLink;
+exports.createSignalIfSupported = createSignalIfSupported;
+exports.defaultPrinter = defaultPrinter;
+exports.fallbackHttpConfig = fallbackHttpConfig;
+exports.parseAndCheckHttpResponse = parseAndCheckHttpResponse;
+exports.rewriteURIForGET = rewriteURIForGET;
+exports.selectHttpOptionsAndBody = selectHttpOptionsAndBody;
+exports.selectHttpOptionsAndBodyInternal = selectHttpOptionsAndBodyInternal;
+exports.selectURI = selectURI;
+exports.serializeFetchParameter = serializeFetchParameter;
+//# sourceMappingURL=http.cjs.map

package/link/persisted-queries/persisted-queries.cjs.native.js

@@ -0,0 +1,174 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var globals = require('../../utilities/globals');
+var graphql = require('graphql');
+var core = require('../core');
+var utilities = require('../../utilities');
+
+var VERSION = 1;
+exports.PersistedQueryLink = void 0;
+(function (PersistedQueryLink) {
+})(exports.PersistedQueryLink || (exports.PersistedQueryLink = {}));
+function collectErrorsByMessage(graphQLErrors) {
+    var collected = Object.create(null);
+    if (utilities.isNonEmptyArray(graphQLErrors)) {
+        graphQLErrors.forEach(function (error) { return collected[error.message] = error; });
+    }
+    return collected;
+}
+var defaultOptions = {
+    disable: function (_a) {
+        var graphQLErrors = _a.graphQLErrors, operation = _a.operation;
+        var errorMessages = collectErrorsByMessage(graphQLErrors);
+        if (errorMessages.PersistedQueryNotSupported) {
+            return true;
+        }
+        if (errorMessages.PersistedQueryNotFound) {
+            return false;
+        }
+        var response = operation.getContext().response;
+        if (response &&
+            response.status &&
+            (response.status === 400 || response.status === 500)) {
+            return true;
+        }
+        return false;
+    },
+    useGETForHashedQueries: false,
+};
+function operationDefinesMutation(operation) {
+    return operation.query.definitions.some(function (d) { return d.kind === 'OperationDefinition' && d.operation === 'mutation'; });
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hashesByQuery = new WeakMap();
+var nextHashesChildKey = 0;
+var createPersistedQueryLink = function (options) {
+    __DEV__ ? globals.invariant(options && (typeof options.sha256 === 'function' ||
+        typeof options.generateHash === 'function'), 'Missing/invalid "sha256" or "generateHash" function. Please ' +
+        'configure one using the "createPersistedQueryLink(options)" options ' +
+        'parameter.') : globals.invariant(options && (typeof options.sha256 === 'function' ||
+        typeof options.generateHash === 'function'), 22);
+    var _a = utilities.compact(defaultOptions, options), sha256 = _a.sha256, _b = _a.generateHash, generateHash = _b === void 0 ? function (query) {
+        return Promise.resolve(sha256(graphql.print(query)));
+    } : _b, disable = _a.disable, useGETForHashedQueries = _a.useGETForHashedQueries;
+    var supportsPersistedQueries = true;
+    var hashesChildKey = 'forLink' + nextHashesChildKey++;
+    var getHashPromise = function (query) {
+        return new Promise(function (resolve) { return resolve(generateHash(query)); });
+    };
+    function getQueryHash(query) {
+        if (!query || typeof query !== 'object') {
+            return getHashPromise(query);
+        }
+        var hashes = hashesByQuery.get(query);
+        if (!hashes)
+            hashesByQuery.set(query, hashes = Object.create(null));
+        return hasOwnProperty.call(hashes, hashesChildKey)
+            ? hashes[hashesChildKey]
+            : hashes[hashesChildKey] = getHashPromise(query);
+    }
+    return new core.ApolloLink(function (operation, forward) {
+        __DEV__ ? globals.invariant(forward, 'PersistedQueryLink cannot be the last link in the chain.') : globals.invariant(forward, 23);
+        var query = operation.query;
+        return new utilities.Observable(function (observer) {
+            var subscription;
+            var retried = false;
+            var originalFetchOptions;
+            var setFetchOptions = false;
+            var retry = function (_a, cb) {
+                var response = _a.response, networkError = _a.networkError;
+                if (!retried && ((response && response.errors) || networkError)) {
+                    retried = true;
+                    var graphQLErrors = [];
+                    var responseErrors = response && response.errors;
+                    if (utilities.isNonEmptyArray(responseErrors)) {
+                        graphQLErrors.push.apply(graphQLErrors, responseErrors);
+                    }
+                    var networkErrors = networkError &&
+                        networkError.result &&
+                        networkError.result.errors;
+                    if (utilities.isNonEmptyArray(networkErrors)) {
+                        graphQLErrors.push.apply(graphQLErrors, networkErrors);
+                    }
+                    var disablePayload = {
+                        response: response,
+                        networkError: networkError,
+                        operation: operation,
+                        graphQLErrors: utilities.isNonEmptyArray(graphQLErrors) ? graphQLErrors : void 0,
+                    };
+                    supportsPersistedQueries = !disable(disablePayload);
+                    if (collectErrorsByMessage(graphQLErrors).PersistedQueryNotFound ||
+                        !supportsPersistedQueries) {
+                        if (subscription)
+                            subscription.unsubscribe();
+                        operation.setContext({
+                            http: {
+                                includeQuery: true,
+                                includeExtensions: supportsPersistedQueries,
+                            },
+                            fetchOptions: {
+                                method: 'POST',
+                            },
+                        });
+                        if (setFetchOptions) {
+                            operation.setContext({ fetchOptions: originalFetchOptions });
+                        }
+                        subscription = forward(operation).subscribe(handler);
+                        return;
+                    }
+                }
+                cb();
+            };
+            var handler = {
+                next: function (response) {
+                    retry({ response: response }, function () { return observer.next(response); });
+                },
+                error: function (networkError) {
+                    retry({ networkError: networkError }, function () { return observer.error(networkError); });
+                },
+                complete: observer.complete.bind(observer),
+            };
+            operation.setContext({
+                http: {
+                    includeQuery: !supportsPersistedQueries,
+                    includeExtensions: supportsPersistedQueries,
+                },
+            });
+            if (useGETForHashedQueries &&
+                supportsPersistedQueries &&
+                !operationDefinesMutation(operation)) {
+                operation.setContext(function (_a) {
+                    var _b = _a.fetchOptions, fetchOptions = _b === void 0 ? {} : _b;
+                    originalFetchOptions = fetchOptions;
+                    return {
+                        fetchOptions: tslib.__assign(tslib.__assign({}, fetchOptions), { method: 'GET' }),
+                    };
+                });
+                setFetchOptions = true;
+            }
+            if (supportsPersistedQueries) {
+                getQueryHash(query).then(function (sha256Hash) {
+                    operation.extensions.persistedQuery = {
+                        version: VERSION,
+                        sha256Hash: sha256Hash,
+                    };
+                    subscription = forward(operation).subscribe(handler);
+                }).catch(observer.error.bind(observer));
+            }
+            else {
+                subscription = forward(operation).subscribe(handler);
+            }
+            return function () {
+                if (subscription)
+                    subscription.unsubscribe();
+            };
+        });
+    });
+};
+
+exports.VERSION = VERSION;
+exports.createPersistedQueryLink = createPersistedQueryLink;
+//# sourceMappingURL=persisted-queries.cjs.map

package/link/retry/retry.cjs.native.js

@@ -0,0 +1,170 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('../core');
+var utilities = require('../../utilities');
+
+function buildDelayFunction(delayOptions) {
+    var _a = delayOptions || {}, _b = _a.initial, initial = _b === void 0 ? 300 : _b, _c = _a.jitter, jitter = _c === void 0 ? true : _c, _d = _a.max, max = _d === void 0 ? Infinity : _d;
+    var baseDelay = jitter ? initial : initial / 2;
+    return function delayFunction(count) {
+        var delay = Math.min(max, baseDelay * Math.pow(2, count));
+        if (jitter) {
+            delay = Math.random() * delay;
+        }
+        return delay;
+    };
+}
+
+function buildRetryFunction(retryOptions) {
+    var _a = retryOptions || {}, retryIf = _a.retryIf, _b = _a.max, max = _b === void 0 ? 5 : _b;
+    return function retryFunction(count, operation, error) {
+        if (count >= max)
+            return false;
+        return retryIf ? retryIf(error, operation) : !!error;
+    };
+}
+
+var RetryableOperation = (function () {
+    function RetryableOperation(operation, nextLink, delayFor, retryIf) {
+        var _this = this;
+        this.operation = operation;
+        this.nextLink = nextLink;
+        this.delayFor = delayFor;
+        this.retryIf = retryIf;
+        this.retryCount = 0;
+        this.values = [];
+        this.complete = false;
+        this.canceled = false;
+        this.observers = [];
+        this.currentSubscription = null;
+        this.onNext = function (value) {
+            _this.values.push(value);
+            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {
+                var observer = _a[_i];
+                if (!observer)
+                    continue;
+                observer.next(value);
+            }
+        };
+        this.onComplete = function () {
+            _this.complete = true;
+            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {
+                var observer = _a[_i];
+                if (!observer)
+                    continue;
+                observer.complete();
+            }
+        };
+        this.onError = function (error) { return tslib.__awaiter(_this, void 0, void 0, function () {
+            var shouldRetry, _i, _a, observer;
+            return tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.retryCount += 1;
+                        return [4, this.retryIf(this.retryCount, this.operation, error)];
+                    case 1:
+                        shouldRetry = _b.sent();
+                        if (shouldRetry) {
+                            this.scheduleRetry(this.delayFor(this.retryCount, this.operation, error));
+                            return [2];
+                        }
+                        this.error = error;
+                        for (_i = 0, _a = this.observers; _i < _a.length; _i++) {
+                            observer = _a[_i];
+                            if (!observer)
+                                continue;
+                            observer.error(error);
+                        }
+                        return [2];
+                }
+            });
+        }); };
+    }
+    RetryableOperation.prototype.subscribe = function (observer) {
+        if (this.canceled) {
+            throw new Error("Subscribing to a retryable link that was canceled is not supported");
+        }
+        this.observers.push(observer);
+        for (var _i = 0, _a = this.values; _i < _a.length; _i++) {
+            var value = _a[_i];
+            observer.next(value);
+        }
+        if (this.complete) {
+            observer.complete();
+        }
+        else if (this.error) {
+            observer.error(this.error);
+        }
+    };
+    RetryableOperation.prototype.unsubscribe = function (observer) {
+        var index = this.observers.indexOf(observer);
+        if (index < 0) {
+            throw new Error("RetryLink BUG! Attempting to unsubscribe unknown observer!");
+        }
+        this.observers[index] = null;
+        if (this.observers.every(function (o) { return o === null; })) {
+            this.cancel();
+        }
+    };
+    RetryableOperation.prototype.start = function () {
+        if (this.currentSubscription)
+            return;
+        this.try();
+    };
+    RetryableOperation.prototype.cancel = function () {
+        if (this.currentSubscription) {
+            this.currentSubscription.unsubscribe();
+        }
+        clearTimeout(this.timerId);
+        this.timerId = undefined;
+        this.currentSubscription = null;
+        this.canceled = true;
+    };
+    RetryableOperation.prototype.try = function () {
+        this.currentSubscription = this.nextLink(this.operation).subscribe({
+            next: this.onNext,
+            error: this.onError,
+            complete: this.onComplete,
+        });
+    };
+    RetryableOperation.prototype.scheduleRetry = function (delay) {
+        var _this = this;
+        if (this.timerId) {
+            throw new Error("RetryLink BUG! Encountered overlapping retries");
+        }
+        this.timerId = setTimeout(function () {
+            _this.timerId = undefined;
+            _this.try();
+        }, delay);
+    };
+    return RetryableOperation;
+}());
+var RetryLink = (function (_super) {
+    tslib.__extends(RetryLink, _super);
+    function RetryLink(options) {
+        var _this = _super.call(this) || this;
+        var _a = options || {}, attempts = _a.attempts, delay = _a.delay;
+        _this.delayFor =
+            typeof delay === 'function' ? delay : buildDelayFunction(delay);
+        _this.retryIf =
+            typeof attempts === 'function' ? attempts : buildRetryFunction(attempts);
+        return _this;
+    }
+    RetryLink.prototype.request = function (operation, nextLink) {
+        var retryable = new RetryableOperation(operation, nextLink, this.delayFor, this.retryIf);
+        retryable.start();
+        return new utilities.Observable(function (observer) {
+            retryable.subscribe(observer);
+            return function () {
+                retryable.unsubscribe(observer);
+            };
+        });
+    };
+    return RetryLink;
+}(core.ApolloLink));
+
+exports.RetryLink = RetryLink;
+//# sourceMappingURL=retry.cjs.map