@apollo/client 3.9.0-alpha.1 → 3.9.0-alpha.3

package/utilities/subscriptions/urql/urql.cjs.native.js

@@ -0,0 +1,364 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utilities = require('../..');
+var tslib = require('tslib');
+var utils = require('../../../link/utils');
+var errors = require('../../../errors');
+var core = require('../../../core');
+
+function asyncIterator(source) {
+    var _a;
+    var iterator = source[Symbol.asyncIterator]();
+    return _a = {
+            next: function () {
+                return iterator.next();
+            }
+        },
+        _a[Symbol.asyncIterator] = function () {
+            return this;
+        },
+        _a;
+}
+
+function nodeStreamIterator(stream) {
+    var cleanup = null;
+    var error = null;
+    var done = false;
+    var data = [];
+    var waiting = [];
+    function onData(chunk) {
+        if (error)
+            return;
+        if (waiting.length) {
+            var shiftedArr = waiting.shift();
+            if (Array.isArray(shiftedArr) && shiftedArr[0]) {
+                return shiftedArr[0]({ value: chunk, done: false });
+            }
+        }
+        data.push(chunk);
+    }
+    function onError(err) {
+        error = err;
+        var all = waiting.slice();
+        all.forEach(function (pair) {
+            pair[1](err);
+        });
+        !cleanup || cleanup();
+    }
+    function onEnd() {
+        done = true;
+        var all = waiting.slice();
+        all.forEach(function (pair) {
+            pair[0]({ value: undefined, done: true });
+        });
+        !cleanup || cleanup();
+    }
+    cleanup = function () {
+        cleanup = null;
+        stream.removeListener("data", onData);
+        stream.removeListener("error", onError);
+        stream.removeListener("end", onEnd);
+        stream.removeListener("finish", onEnd);
+        stream.removeListener("close", onEnd);
+    };
+    stream.on("data", onData);
+    stream.on("error", onError);
+    stream.on("end", onEnd);
+    stream.on("finish", onEnd);
+    stream.on("close", onEnd);
+    function getNext() {
+        return new Promise(function (resolve, reject) {
+            if (error)
+                return reject(error);
+            if (data.length)
+                return resolve({ value: data.shift(), done: false });
+            if (done)
+                return resolve({ value: undefined, done: true });
+            waiting.push([resolve, reject]);
+        });
+    }
+    var iterator = {
+        next: function () {
+            return getNext();
+        },
+    };
+    if (utilities.canUseAsyncIteratorSymbol) {
+        iterator[Symbol.asyncIterator] = function () {
+            return this;
+        };
+    }
+    return iterator;
+}
+
+function promiseIterator(promise) {
+    var resolved = false;
+    var iterator = {
+        next: function () {
+            if (resolved)
+                return Promise.resolve({
+                    value: undefined,
+                    done: true,
+                });
+            resolved = true;
+            return new Promise(function (resolve, reject) {
+                promise
+                    .then(function (value) {
+                    resolve({ value: value, done: false });
+                })
+                    .catch(reject);
+            });
+        },
+    };
+    if (utilities.canUseAsyncIteratorSymbol) {
+        iterator[Symbol.asyncIterator] = function () {
+            return this;
+        };
+    }
+    return iterator;
+}
+
+function readerIterator(reader) {
+    var iterator = {
+        next: function () {
+            return reader.read();
+        },
+    };
+    if (utilities.canUseAsyncIteratorSymbol) {
+        iterator[Symbol.asyncIterator] = function () {
+            return this;
+        };
+    }
+    return iterator;
+}
+
+function isNodeResponse(value) {
+    return !!value.body;
+}
+function isReadableStream(value) {
+    return !!value.getReader;
+}
+function isAsyncIterableIterator(value) {
+    return !!(utilities.canUseAsyncIteratorSymbol &&
+        value[Symbol.asyncIterator]);
+}
+function isStreamableBlob(value) {
+    return !!value.stream;
+}
+function isBlob(value) {
+    return !!value.arrayBuffer;
+}
+function isNodeReadableStream(value) {
+    return !!value.pipe;
+}
+function responseIterator(response) {
+    var body = response;
+    if (isNodeResponse(response))
+        body = response.body;
+    if (isAsyncIterableIterator(body))
+        return asyncIterator(body);
+    if (isReadableStream(body))
+        return readerIterator(body.getReader());
+    if (isStreamableBlob(body)) {
+        return readerIterator(body.stream().getReader());
+    }
+    if (isBlob(body))
+        return promiseIterator(body.arrayBuffer());
+    if (isNodeReadableStream(body))
+        return nodeStreamIterator(body);
+    throw new Error("Unknown body type for responseIterator. Please pass a streamable response.");
+}
+
+function isNonNullObject(obj) {
+    return obj !== null && typeof obj === "object";
+}
+
+function isApolloPayloadResult(value) {
+    return isNonNullObject(value) && "payload" in value;
+}
+
+function readMultipartBody(response, nextValue) {
+    var _a;
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _b, value, done, chunk, searchFrom, bi, message, i, headers, contentType_1, body, result, next;
+        var _c, _d;
+        return tslib.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    if (TextDecoder === undefined) {
+                        throw new Error("TextDecoder must be defined in the environment: please import a polyfill.");
+                    }
+                    decoder = new TextDecoder("utf-8");
+                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get("content-type");
+                    delimiter = "boundary=";
+                    boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter))
+                        ? contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['"]/g, "").replace(/\;(.*)/gm, "").trim()
+                        : "-";
+                    boundary = "\r\n--".concat(boundaryVal);
+                    buffer = "";
+                    iterator = responseIterator(response);
+                    running = true;
+                    _e.label = 1;
+                case 1:
+                    if (!running) return [3, 3];
+                    return [4, iterator.next()];
+                case 2:
+                    _b = _e.sent(), value = _b.value, done = _b.done;
+                    chunk = typeof value === "string" ? value : decoder.decode(value);
+                    searchFrom = buffer.length - boundary.length + 1;
+                    running = !done;
+                    buffer += chunk;
+                    bi = buffer.indexOf(boundary, searchFrom);
+                    while (bi > -1) {
+                        message = void 0;
+                        _c = [
+                            buffer.slice(0, bi),
+                            buffer.slice(bi + boundary.length),
+                        ], message = _c[0], buffer = _c[1];
+                        i = message.indexOf("\r\n\r\n");
+                        headers = parseHeaders(message.slice(0, i));
+                        contentType_1 = headers["content-type"];
+                        if (contentType_1 &&
+                            contentType_1.toLowerCase().indexOf("application/json") === -1) {
+                            throw new Error("Unsupported patch content type: application/json is required.");
+                        }
+                        body = message.slice(i);
+                        if (body) {
+                            result = parseJsonBody(response, body);
+                            if (Object.keys(result).length > 1 ||
+                                "data" in result ||
+                                "incremental" in result ||
+                                "errors" in result ||
+                                "payload" in result) {
+                                if (isApolloPayloadResult(result)) {
+                                    next = {};
+                                    if ("payload" in result) {
+                                        next = tslib.__assign({}, result.payload);
+                                    }
+                                    if ("errors" in result) {
+                                        next = tslib.__assign(tslib.__assign({}, next), { extensions: tslib.__assign(tslib.__assign({}, ("extensions" in next ? next.extensions : null)), (_d = {}, _d[errors.PROTOCOL_ERRORS_SYMBOL] = result.errors, _d)) });
+                                    }
+                                    nextValue(next);
+                                }
+                                else {
+                                    nextValue(result);
+                                }
+                            }
+                            else if (Object.keys(result).length === 1 &&
+                                "hasNext" in result &&
+                                !result.hasNext) {
+                                return [2];
+                            }
+                        }
+                        bi = buffer.indexOf(boundary);
+                    }
+                    return [3, 1];
+                case 3: return [2];
+            }
+        });
+    });
+}
+function parseHeaders(headerText) {
+    var headersInit = {};
+    headerText.split("\n").forEach(function (line) {
+        var i = line.indexOf(":");
+        if (i > -1) {
+            var name_1 = line.slice(0, i).trim().toLowerCase();
+            var value = line.slice(i + 1).trim();
+            headersInit[name_1] = value;
+        }
+    });
+    return headersInit;
+}
+function parseJsonBody(response, bodyText) {
+    if (response.status >= 300) {
+        var getResult = function () {
+            try {
+                return JSON.parse(bodyText);
+            }
+            catch (err) {
+                return bodyText;
+            }
+        };
+        utils.throwServerError(response, getResult(), "Response not successful: Received status code ".concat(response.status));
+    }
+    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;
+    }
+}
+function handleError(err, observer) {
+    if (err.result && err.result.errors && err.result.data) {
+        observer.next(err.result);
+    }
+    observer.error(err);
+}
+
+var defaultHttpOptions = {
+    includeQuery: true,
+    includeExtensions: false,
+    preserveHeaderCase: false,
+};
+var defaultHeaders = {
+    accept: "*/*",
+    "content-type": "application/json",
+};
+var defaultOptions = {
+    method: "POST",
+};
+var fallbackHttpConfig = {
+    http: defaultHttpOptions,
+    headers: defaultHeaders,
+    options: defaultOptions,
+};
+
+function generateOptionsForMultipartSubscription(headers) {
+    var options = tslib.__assign(tslib.__assign({}, fallbackHttpConfig.options), { headers: tslib.__assign(tslib.__assign(tslib.__assign({}, (headers || {})), fallbackHttpConfig.headers), { accept: "multipart/mixed;boundary=graphql;subscriptionSpec=1.0,application/json" }) });
+    return options;
+}
+
+var backupFetch = utilities.maybe(function () { return fetch; });
+function createFetchMultipartSubscription(uri, _a) {
+    var _b = _a === void 0 ? {} : _a, preferredFetch = _b.fetch, headers = _b.headers;
+    return function multipartSubscriptionForwarder(_a) {
+        var query = _a.query, variables = _a.variables;
+        var body = { variables: variables, query: query };
+        var options = generateOptionsForMultipartSubscription(headers || {});
+        return new utilities.Observable(function (observer) {
+            try {
+                options.body = core.serializeFetchParameter(body, "Payload");
+            }
+            catch (parseError) {
+                observer.error(parseError);
+            }
+            var currentFetch = preferredFetch || utilities.maybe(function () { return fetch; }) || backupFetch;
+            var observerNext = observer.next.bind(observer);
+            currentFetch(uri, options)
+                .then(function (response) {
+                var _a;
+                var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get("content-type");
+                if (ctype !== null && /^multipart\/mixed/i.test(ctype)) {
+                    return readMultipartBody(response, observerNext);
+                }
+                observer.error(new Error("Expected multipart response"));
+            })
+                .then(function () {
+                observer.complete();
+            })
+                .catch(function (err) {
+                handleError(err, observer);
+            });
+        });
+    };
+}
+
+exports.createFetchMultipartSubscription = createFetchMultipartSubscription;
+//# sourceMappingURL=urql.cjs.map

package/utilities/utilities.cjs

@@ -20,7 +20,7 @@ function shouldInclude(_a, variables) {
         if (ifArgument.value.kind === "Variable") {
             evaledValue =
                 variables && variables[ifArgument.value.name.value];
-            globals.invariant(evaledValue !== void 0, 65, directive.name.value);
+            globals.invariant(evaledValue !== void 0, 67, directive.name.value);
         }
         else {
             evaledValue = ifArgument.value.value;
@@ -70,12 +70,12 @@ function getInclusionDirectives(directives) {
                 return;
             var directiveArguments = directive.arguments;
             var directiveName = directive.name.value;
-            globals.invariant(directiveArguments && directiveArguments.length === 1, 66, directiveName);
+            globals.invariant(directiveArguments && directiveArguments.length === 1, 68, directiveName);
             var ifArgument = directiveArguments[0];
-            globals.invariant(ifArgument.name && ifArgument.name.value === "if", 67, directiveName);
+            globals.invariant(ifArgument.name && ifArgument.name.value === "if", 69, directiveName);
             var ifValue = ifArgument.value;
             globals.invariant(ifValue &&
-                (ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 68, directiveName);
+                (ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 70, directiveName);
             result.push({ directive: directive, ifArgument: ifArgument });
         });
     }
@@ -107,7 +107,7 @@ function getFragmentQueryDocument(document, fragmentName) {
     document.definitions.forEach(function (definition) {
         if (definition.kind === "OperationDefinition") {
             throw globals.newInvariantError(
-                69,
+                71,
                 definition.operation,
                 definition.name ? " named '".concat(definition.name.value, "'") : ""
             );
@@ -117,7 +117,7 @@ function getFragmentQueryDocument(document, fragmentName) {
         }
     });
     if (typeof actualFragmentName === "undefined") {
-        globals.invariant(fragments.length === 1, 70, fragments.length);
+        globals.invariant(fragments.length === 1, 72, fragments.length);
         actualFragmentName = fragments[0].name.value;
     }
     var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
@@ -158,7 +158,7 @@ function getFragmentFromSelection(selection, fragmentMap) {
                 return fragmentMap(fragmentName);
             }
             var fragment = fragmentMap && fragmentMap[fragmentName];
-            globals.invariant(fragment, 71, fragmentName);
+            globals.invariant(fragment, 73, fragmentName);
             return fragment || null;
         }
         default:
@@ -166,6 +166,43 @@ function getFragmentFromSelection(selection, fragmentMap) {
     }
 }
 
+var canonicalStringify = Object.assign(function canonicalStringify(value) {
+    return JSON.stringify(value, stableObjectReplacer);
+}, {
+    reset: function () {
+        sortingMap.clear();
+    },
+});
+var sortingMap = new Map();
+function stableObjectReplacer(key, value) {
+    if (value && typeof value === "object") {
+        var proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) {
+            var keys = Object.keys(value);
+            if (keys.every(everyKeyInOrder))
+                return value;
+            var unsortedKey = JSON.stringify(keys);
+            var sortedKeys = sortingMap.get(unsortedKey);
+            if (!sortedKeys) {
+                keys.sort();
+                var sortedKey = JSON.stringify(keys);
+                sortedKeys = sortingMap.get(sortedKey) || keys;
+                sortingMap.set(unsortedKey, sortedKeys);
+                sortingMap.set(sortedKey, sortedKeys);
+            }
+            var sortedObject_1 = Object.create(proto);
+            sortedKeys.forEach(function (key) {
+                sortedObject_1[key] = value[key];
+            });
+            return sortedObject_1;
+        }
+    }
+    return value;
+}
+function everyKeyInOrder(key, i, keys) {
+    return i === 0 || keys[i - 1] <= key;
+}
+
 function makeReference(id) {
     return { __ref: String(id) };
 }
@@ -236,7 +273,7 @@ function valueToObjectRepresentation(argObj, name, value, variables) {
         argObj[name.value] = null;
     }
     else {
-        throw globals.newInvariantError(80, name.value, value.kind);
+        throw globals.newInvariantError(82, name.value, value.kind);
     }
 }
 function storeKeyNameFromField(field, variables) {
@@ -272,6 +309,7 @@ var KNOWN_DIRECTIVES = [
     "export",
     "nonreactive",
 ];
+var storeKeyNameStringify = canonicalStringify;
 var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
     if (args &&
         directives &&
@@ -287,7 +325,7 @@ var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
             filterKeys.forEach(function (key) {
                 filteredArgs_1[key] = args[key];
             });
-            return "".concat(directives["connection"]["key"], "(").concat(stringify(filteredArgs_1), ")");
+            return "".concat(directives["connection"]["key"], "(").concat(storeKeyNameStringify(filteredArgs_1), ")");
         }
         else {
             return directives["connection"]["key"];
@@ -295,7 +333,7 @@ var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
     }
     var completeFieldName = fieldName;
     if (args) {
-        var stringifiedArgs = stringify(args);
+        var stringifiedArgs = storeKeyNameStringify(args);
         completeFieldName += "(".concat(stringifiedArgs, ")");
     }
     if (directives) {
@@ -303,7 +341,7 @@ var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
             if (KNOWN_DIRECTIVES.indexOf(key) !== -1)
                 return;
             if (directives[key] && Object.keys(directives[key]).length) {
-                completeFieldName += "@".concat(key, "(").concat(stringify(directives[key]), ")");
+                completeFieldName += "@".concat(key, "(").concat(storeKeyNameStringify(directives[key]), ")");
             }
             else {
                 completeFieldName += "@".concat(key);
@@ -313,25 +351,11 @@ var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
     return completeFieldName;
 }, {
     setStringify: function (s) {
-        var previous = stringify;
-        stringify = s;
+        var previous = storeKeyNameStringify;
+        storeKeyNameStringify = s;
         return previous;
     },
 });
-var stringify = function defaultStringify(value) {
-    return JSON.stringify(value, stringifyReplacer);
-};
-function stringifyReplacer(_key, value) {
-    if (isNonNullObject(value) && !Array.isArray(value)) {
-        value = Object.keys(value)
-            .sort()
-            .reduce(function (copy, key) {
-            copy[key] = value[key];
-            return copy;
-        }, {});
-    }
-    return value;
-}
 function argumentsObjectFromField(field, variables) {
     if (field.arguments && field.arguments.length) {
         var argObj_1 = {};
@@ -383,16 +407,16 @@ function isInlineFragment(selection) {
 }
 
 function checkDocument(doc) {
-    globals.invariant(doc && doc.kind === "Document", 72);
+    globals.invariant(doc && doc.kind === "Document", 74);
     var operations = doc.definitions
         .filter(function (d) { return d.kind !== "FragmentDefinition"; })
         .map(function (definition) {
         if (definition.kind !== "OperationDefinition") {
-            throw globals.newInvariantError(73, definition.kind);
+            throw globals.newInvariantError(75, definition.kind);
         }
         return definition;
     });
-    globals.invariant(operations.length <= 1, 74, operations.length);
+    globals.invariant(operations.length <= 1, 76, operations.length);
     return doc;
 }
 function getOperationDefinition(doc) {
@@ -415,14 +439,14 @@ function getFragmentDefinitions(doc) {
 }
 function getQueryDefinition(doc) {
     var queryDef = getOperationDefinition(doc);
-    globals.invariant(queryDef && queryDef.operation === "query", 75);
+    globals.invariant(queryDef && queryDef.operation === "query", 77);
     return queryDef;
 }
 function getFragmentDefinition(doc) {
-    globals.invariant(doc.kind === "Document", 76);
-    globals.invariant(doc.definitions.length <= 1, 77);
+    globals.invariant(doc.kind === "Document", 78);
+    globals.invariant(doc.definitions.length <= 1, 79);
     var fragmentDef = doc.definitions[0];
-    globals.invariant(fragmentDef.kind === "FragmentDefinition", 78);
+    globals.invariant(fragmentDef.kind === "FragmentDefinition", 80);
     return fragmentDef;
 }
 function getMainDefinition(queryDoc) {
@@ -445,7 +469,7 @@ function getMainDefinition(queryDoc) {
     if (fragmentDefinition) {
         return fragmentDefinition;
     }
-    throw globals.newInvariantError(79);
+    throw globals.newInvariantError(81);
 }
 function getDefaultValues(definition) {
     var defaultValues = Object.create(null);
@@ -517,7 +541,7 @@ var DocumentTransform = (function () {
             return;
         var cacheKeys = this.getCacheKey(document);
         if (cacheKeys) {
-            globals.invariant(Array.isArray(cacheKeys), 64);
+            globals.invariant(Array.isArray(cacheKeys), 66);
             return this.stableCacheKeys.lookupArray(cacheKeys);
         }
     };
@@ -613,7 +637,7 @@ function removeDirectivesFromDocument(directives, doc) {
                 return getInUseByFragmentName(ancestor.name.value);
             }
         }
-        globalThis.__DEV__ !== false && globals.invariant.error(81);
+        globalThis.__DEV__ !== false && globals.invariant.error(83);
         return null;
     };
     var operationCount = 0;
@@ -800,7 +824,7 @@ var connectionRemoveConfig = {
         if (willRemove) {
             if (!directive.arguments ||
                 !directive.arguments.some(function (arg) { return arg.name.value === "key"; })) {
-                globalThis.__DEV__ !== false && globals.invariant.warn(82);
+                globalThis.__DEV__ !== false && globals.invariant.warn(84);
             }
         }
         return willRemove;
@@ -1249,48 +1273,31 @@ function iterateObserversSafely(observers, method, argument) {
 
 function asyncMap(observable, mapFn, catchFn) {
     return new zenObservableTs.Observable(function (observer) {
-        var next = observer.next, error = observer.error, complete = observer.complete;
-        var activeCallbackCount = 0;
-        var completed = false;
         var promiseQueue = {
             then: function (callback) {
                 return new Promise(function (resolve) { return resolve(callback()); });
             },
         };
-        function makeCallback(examiner, delegate) {
-            if (examiner) {
-                return function (arg) {
-                    ++activeCallbackCount;
-                    var both = function () { return examiner(arg); };
-                    promiseQueue = promiseQueue
-                        .then(both, both)
-                        .then(function (result) {
-                        --activeCallbackCount;
-                        next && next.call(observer, result);
-                        if (completed) {
-                            handler.complete();
-                        }
-                    }, function (error) {
-                        --activeCallbackCount;
-                        throw error;
-                    })
-                        .catch(function (caught) {
-                        error && error.call(observer, caught);
-                    });
-                };
-            }
-            else {
-                return function (arg) { return delegate && delegate.call(observer, arg); };
-            }
+        function makeCallback(examiner, key) {
+            return function (arg) {
+                if (examiner) {
+                    var both = function () {
+                        return observer.closed
+                            ? 0
+                            : examiner(arg);
+                    };
+                    promiseQueue = promiseQueue.then(both, both).then(function (result) { return observer.next(result); }, function (error) { return observer.error(error); });
+                }
+                else {
+                    observer[key](arg);
+                }
+            };
         }
         var handler = {
-            next: makeCallback(mapFn, next),
-            error: makeCallback(catchFn, error),
+            next: makeCallback(mapFn, "next"),
+            error: makeCallback(catchFn, "error"),
             complete: function () {
-                completed = true;
-                if (!activeCallbackCount) {
-                    complete && complete.call(observer);
-                }
+                promiseQueue.then(function () { return observer.complete(); });
             },
         };
         var sub = observable.subscribe(handler);
@@ -1591,6 +1598,7 @@ exports.canUseLayoutEffect = canUseLayoutEffect;
 exports.canUseSymbol = canUseSymbol;
 exports.canUseWeakMap = canUseWeakMap;
 exports.canUseWeakSet = canUseWeakSet;
+exports.canonicalStringify = canonicalStringify;
 exports.checkDocument = checkDocument;
 exports.cloneDeep = cloneDeep;
 exports.compact = compact;