@apollo/client 3.9.0-alpha.2 → 3.9.0-alpha.4

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:
@@ -273,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) {
@@ -407,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) {
@@ -439,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) {
@@ -469,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);
@@ -541,15 +541,15 @@ 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);
         }
     };
     return DocumentTransform;
 }());
 
-var printCache = canUseWeakMap ? new WeakMap() : undefined;
-var print = function (ast) {
+var printCache;
+var print = Object.assign(function (ast) {
     var result;
     result = printCache === null || printCache === void 0 ? void 0 : printCache.get(ast);
     if (!result) {
@@ -557,7 +557,12 @@ var print = function (ast) {
         printCache === null || printCache === void 0 ? void 0 : printCache.set(ast, result);
     }
     return result;
-};
+}, {
+    reset: function () {
+        printCache = canUseWeakMap ? new WeakMap() : undefined;
+    },
+});
+print.reset();
 
 var isArray = Array.isArray;
 function isNonEmptyArray(value) {
@@ -637,7 +642,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;
@@ -824,7 +829,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;