relay-runtime 7.0.0 → 9.1.0

package/lib/store/RelayModernQueryExecutor.js

@@ -8,15 +8,24 @@
  * @format
  * @emails oncall+relay
  */
+// flowlint ambiguous-object-type:error
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
-var RelayConnectionInterface = require('../handlers/connection/RelayConnectionInterface');
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 var RelayError = require('../util/RelayError');
 
@@ -55,38 +64,45 @@ function execute(config) {
  */
 
 
-var Executor =
-/*#__PURE__*/
-function () {
+var Executor = /*#__PURE__*/function () {
   function Executor(_ref) {
     var _this = this;
 
     var operation = _ref.operation,
+        operationExecutions = _ref.operationExecutions,
         operationLoader = _ref.operationLoader,
         optimisticConfig = _ref.optimisticConfig,
         publishQueue = _ref.publishQueue,
         scheduler = _ref.scheduler,
         sink = _ref.sink,
         source = _ref.source,
+        store = _ref.store,
         updater = _ref.updater,
         operationTracker = _ref.operationTracker,
-        getDataID = _ref.getDataID;
+        treatMissingFieldsAsNull = _ref.treatMissingFieldsAsNull,
+        getDataID = _ref.getDataID,
+        isClientPayload = _ref.isClientPayload;
+    this._getDataID = getDataID;
+    this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
+    this._incrementalPayloadsPending = false;
     this._incrementalResults = new Map();
     this._nextSubscriptionId = 0;
     this._operation = operation;
+    this._operationExecutions = operationExecutions;
     this._operationLoader = operationLoader;
+    this._operationTracker = operationTracker;
+    this._operationUpdateEpochs = new Map();
     this._optimisticUpdates = null;
+    this._pendingModulePayloadsCount = 0;
     this._publishQueue = publishQueue;
     this._scheduler = scheduler;
     this._sink = sink;
     this._source = new Map();
     this._state = 'started';
-    this._updater = updater;
+    this._store = store;
     this._subscriptions = new Map();
-    this._operationTracker = operationTracker;
-    this._getDataID = getDataID;
-    this._incrementalPayloadsPending = false;
-    this._pendingModulePayloadsCount = 0;
+    this._updater = updater;
+    this._isClientPayload = isClientPayload === true;
     var id = this._nextSubscriptionId++;
     source.subscribe({
       complete: function complete() {
@@ -110,7 +126,7 @@ function () {
     if (optimisticConfig != null) {
       this._processOptimisticResponse(optimisticConfig.response != null ? {
         data: optimisticConfig.response
-      } : null, optimisticConfig.updater);
+      } : null, optimisticConfig.updater, false);
     }
   } // Cancel any pending execution tasks and mark the executor as completed.
 
@@ -126,6 +142,8 @@ function () {
 
     this._state = 'completed';
 
+    this._operationExecutions["delete"](this._operation.request.identifier);
+
     if (this._subscriptions.size !== 0) {
       this._subscriptions.forEach(function (sub) {
         return sub.unsubscribe();
@@ -150,6 +168,42 @@ function () {
     this._completeOperationTracker();
   };
 
+  _proto._updateActiveState = function _updateActiveState() {
+    var activeState;
+
+    switch (this._state) {
+      case 'started':
+        {
+          activeState = 'active';
+          break;
+        }
+
+      case 'loading_incremental':
+        {
+          activeState = 'active';
+          break;
+        }
+
+      case 'completed':
+        {
+          activeState = 'inactive';
+          break;
+        }
+
+      case 'loading_final':
+        {
+          activeState = this._pendingModulePayloadsCount > 0 ? 'active' : 'inactive';
+          break;
+        }
+
+      default:
+        this._state;
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernQueryExecutor: invalid executor state.') : invariant(false) : void 0;
+    }
+
+    this._operationExecutions.set(this._operation.request.identifier, activeState);
+  };
+
   _proto._schedule = function _schedule(task) {
     var _this3 = this;
 
@@ -204,6 +258,8 @@ function () {
 
   _proto._start = function _start(id, subscription) {
     this._subscriptions.set(id, subscription);
+
+    this._updateActiveState();
   } // Handle a raw GraphQL response.
   ;
 
@@ -217,69 +273,155 @@ function () {
     });
   };
 
-  _proto._handleNext = function _handleNext(response) {
-    var _response$extensions, _response$extensions2;
+  _proto._handleErrorResponse = function _handleErrorResponse(responses) {
+    var _this5 = this;
 
-    if (this._state === 'completed') {
-      return;
-    }
+    var results = [];
+    responses.forEach(function (response) {
+      if (response.data === null && response.extensions != null && !response.hasOwnProperty('errors')) {
+        // Skip extensions-only payloads
+        return;
+      } else if (response.data == null) {
+        // Error if any other payload in the batch is missing data, regardless of whether
+        // it had `errors` or not.
+        var errors = response.hasOwnProperty('errors') && response.errors != null ? response.errors : null;
+        var messages = errors ? errors.map(function (_ref2) {
+          var message = _ref2.message;
+          return message;
+        }).join('\n') : '(No errors)';
+        var error = RelayError.create('RelayNetwork', 'No data returned for operation `' + _this5._operation.request.node.params.name + '`, got error(s):\n' + messages + '\n\nSee the error `source` property for more information.');
+        error.source = {
+          errors: errors,
+          operation: _this5._operation.request.node,
+          variables: _this5._operation.request.variables
+        };
+        throw error;
+      } else {
+        var responseWithData = response;
+        results.push(responseWithData);
+      }
+    });
+    return results;
+  }
+  /**
+   * This method return boolean to indicate if the optimistic
+   * response has been handled
+   */
+  ;
 
-    if (response.data == null) {
-      var errors = response.errors;
-      var messages = errors ? errors.map(function (_ref2) {
-        var message = _ref2.message;
-        return message;
-      }).join('\n') : '(No errors)';
-      var error = RelayError.create('RelayNetwork', 'No data returned for operation `' + this._operation.request.node.params.name + '`, got error(s):\n' + messages + '\n\nSee the error `source` property for more information.');
-      error.source = {
-        errors: errors,
-        operation: this._operation.request.node,
-        variables: this._operation.request.variables
-      };
-      throw error;
-    } // Above check ensures that response.data != null
+  _proto._handleOptimisticResponses = function _handleOptimisticResponses(responses) {
+    var _response$extensions;
 
+    if (responses.length > 1) {
+      if (responses.some(function (responsePart) {
+        var _responsePart$extensi;
 
-    var responseWithData = response;
+        return ((_responsePart$extensi = responsePart.extensions) === null || _responsePart$extensi === void 0 ? void 0 : _responsePart$extensi.isOptimistic) === true;
+      })) {
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Optimistic responses cannot be batched.') : invariant(false) : void 0;
+      }
+
+      return false;
+    }
+
+    var response = responses[0];
     var isOptimistic = ((_response$extensions = response.extensions) === null || _response$extensions === void 0 ? void 0 : _response$extensions.isOptimistic) === true;
 
     if (isOptimistic && this._state !== 'started') {
       !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernQueryExecutor: optimistic payload received after server payload.') : invariant(false) : void 0;
     }
 
-    var isFinal = ((_response$extensions2 = response.extensions) === null || _response$extensions2 === void 0 ? void 0 : _response$extensions2.is_final) === true;
-    this._state = isFinal ? 'loading_final' : 'loading_incremental';
+    if (isOptimistic) {
+      this._processOptimisticResponse(response, null, this._treatMissingFieldsAsNull);
+
+      this._sink.next(response);
 
-    if (isFinal) {
-      this._incrementalPayloadsPending = false;
+      return true;
     }
 
-    if (isOptimistic) {
-      this._processOptimisticResponse(responseWithData, null);
-    } else {
-      var path = response.path,
-          label = response.label;
-
-      if (path != null || label != null) {
-        if (typeof label === 'string' && Array.isArray(path)) {
-          this._processIncrementalResponse({
-            path: path,
-            label: label,
-            response: responseWithData
-          });
-        } else {
-          !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernQueryExecutor: invalid incremental payload, expected ' + '`path` and `label` to either both be null/undefined, or ' + '`path` to be an `Array<string | number>` and `label` to be a ' + '`string`.') : invariant(false) : void 0;
-        }
-      } else {
-        this._processResponse(responseWithData);
+    return false;
+  };
+
+  _proto._handleNext = function _handleNext(response) {
+    if (this._state === 'completed') {
+      return;
+    }
+
+    var responses = Array.isArray(response) ? response : [response];
+
+    var responsesWithData = this._handleErrorResponse(responses);
+
+    if (responsesWithData.length === 0) {
+      // no results with data, nothing to process
+      // this can occur with extensions-only payloads
+      var isFinal = responses.some(function (x) {
+        var _x$extensions;
+
+        return ((_x$extensions = x.extensions) === null || _x$extensions === void 0 ? void 0 : _x$extensions.is_final) === true;
+      });
+
+      if (isFinal) {
+        this._state = 'loading_final';
+
+        this._updateActiveState();
+
+        this._incrementalPayloadsPending = false;
       }
+
+      this._sink.next(response);
+
+      return;
+    } // Next, handle optimistic responses
+
+
+    var isOptimistic = this._handleOptimisticResponses(responsesWithData);
+
+    if (isOptimistic) {
+      return;
+    }
+
+    var _partitionGraphQLResp = partitionGraphQLResponses(responsesWithData),
+        nonIncrementalResponses = _partitionGraphQLResp[0],
+        incrementalResponses = _partitionGraphQLResp[1]; // In theory this doesn't preserve the ordering of the batch.
+    // The idea is that a batch is always:
+    //  * at-most one non-incremental payload
+    //  * followed zero or more incremental payloads
+    // The non-incremental payload can appear if the server sends a batch
+    // w the initial payload followed by some early-to-resolve incremental
+    // payloads (although, can that even happen?)
+
+
+    if (nonIncrementalResponses.length > 0) {
+      var payloadFollowups = this._processResponses(nonIncrementalResponses); // Please note, that we're passing `this._operation` to the publish
+      // queue here, which will later passed to the store (via notify)
+      // to indicate that this is an operation that cause the store to update
+
+
+      var updatedOwners = this._publishQueue.run(this._operation);
+
+      this._updateOperationTracker(updatedOwners);
+
+      this._processPayloadFollowups(payloadFollowups);
+    }
+
+    if (incrementalResponses.length > 0) {
+      var _payloadFollowups = this._processIncrementalResponses(incrementalResponses); // For the incremental case, we're only handling follow-up responses
+      // for already initiated operation (and we're not passing it to
+      // the run(...) call)
+
+
+      var _updatedOwners = this._publishQueue.run();
+
+      this._updateOperationTracker(_updatedOwners);
+
+      this._processPayloadFollowups(_payloadFollowups);
     }
 
     this._sink.next(response);
   };
 
-  _proto._processOptimisticResponse = function _processOptimisticResponse(response, updater) {
-    var _this5 = this;
+  _proto._processOptimisticResponse = function _processOptimisticResponse(response, updater, treatMissingFieldsAsNull) {
+    var _this6 = this;
 
     !(this._optimisticUpdates === null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'environment.execute: only support one optimistic response per ' + 'execute.') : invariant(false) : void 0;
 
@@ -293,7 +435,8 @@ function () {
       var payload = normalizeResponse(response, this._operation.root, ROOT_TYPE, {
         getDataID: this._getDataID,
         path: [],
-        request: this._operation.request
+        request: this._operation.request,
+        treatMissingFieldsAsNull: treatMissingFieldsAsNull
       });
       validateOptimisticResponsePayload(payload);
       optimisticUpdates.push({
@@ -302,49 +445,17 @@ function () {
         updater: updater
       });
 
-      if (payload.moduleImportPayloads && payload.moduleImportPayloads.length) {
-        var moduleImportPayloads = payload.moduleImportPayloads;
-        var operationLoader = this._operationLoader;
-        !operationLoader ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;
-
-        while (moduleImportPayloads.length) {
-          var moduleImportPayload = moduleImportPayloads.shift();
-          var operation = operationLoader.get(moduleImportPayload.operationReference);
-
-          if (operation == null) {
-            continue;
-          }
-
-          var selector = createNormalizationSelector(operation, moduleImportPayload.dataID, moduleImportPayload.variables);
-          var modulePayload = normalizeResponse({
-            data: moduleImportPayload.data
-          }, selector, moduleImportPayload.typeName, {
-            getDataID: this._getDataID,
-            path: moduleImportPayload.path,
-            request: this._operation.request
-          });
-          validateOptimisticResponsePayload(modulePayload);
-          optimisticUpdates.push({
-            operation: this._operation,
-            payload: modulePayload,
-            updater: null
-          });
-
-          if (modulePayload.moduleImportPayloads) {
-            moduleImportPayloads.push.apply(moduleImportPayloads, (0, _toConsumableArray2["default"])(modulePayload.moduleImportPayloads));
-          }
-        }
-      }
+      this._processOptimisticFollowups(payload, optimisticUpdates);
     } else if (updater) {
       optimisticUpdates.push({
         operation: this._operation,
         payload: {
-          connectionEvents: null,
           errors: null,
           fieldPayloads: null,
           incrementalPlaceholders: null,
           moduleImportPayloads: null,
-          source: RelayRecordSource.create()
+          source: RelayRecordSource.create(),
+          isFinal: false
         },
         updater: updater
       });
@@ -352,41 +463,126 @@ function () {
 
     this._optimisticUpdates = optimisticUpdates;
     optimisticUpdates.forEach(function (update) {
-      return _this5._publishQueue.applyUpdate(update);
+      return _this6._publishQueue.applyUpdate(update);
     });
 
     this._publishQueue.run();
   };
 
-  _proto._processResponse = function _processResponse(response) {
-    var _this6 = this;
+  _proto._processOptimisticFollowups = function _processOptimisticFollowups(payload, optimisticUpdates) {
+    if (payload.moduleImportPayloads && payload.moduleImportPayloads.length) {
+      var moduleImportPayloads = payload.moduleImportPayloads;
+      var operationLoader = this._operationLoader;
+      !operationLoader ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;
+
+      var _iterator = _createForOfIteratorHelper(moduleImportPayloads),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var moduleImportPayload = _step.value;
+          var operation = operationLoader.get(moduleImportPayload.operationReference);
+
+          if (operation == null) {
+            this._processAsyncOptimisticModuleImport(operationLoader, moduleImportPayload);
+          } else {
+            var moduleImportOptimisitcUpdates = this._processOptimisticModuleImport(operation, moduleImportPayload);
+
+            optimisticUpdates.push.apply(optimisticUpdates, (0, _toConsumableArray2["default"])(moduleImportOptimisitcUpdates));
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  };
+
+  _proto._normalizeModuleImport = function _normalizeModuleImport(moduleImportPayload, operation) {
+    var selector = createNormalizationSelector(operation, moduleImportPayload.dataID, moduleImportPayload.variables);
+    return normalizeResponse({
+      data: moduleImportPayload.data
+    }, selector, moduleImportPayload.typeName, {
+      getDataID: this._getDataID,
+      path: moduleImportPayload.path,
+      request: this._operation.request,
+      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull
+    });
+  };
+
+  _proto._processOptimisticModuleImport = function _processOptimisticModuleImport(operation, moduleImportPayload) {
+    var optimisticUpdates = [];
+
+    var modulePayload = this._normalizeModuleImport(moduleImportPayload, operation);
+
+    validateOptimisticResponsePayload(modulePayload);
+    optimisticUpdates.push({
+      operation: this._operation,
+      payload: modulePayload,
+      updater: null
+    });
+
+    this._processOptimisticFollowups(modulePayload, optimisticUpdates);
+
+    return optimisticUpdates;
+  };
+
+  _proto._processAsyncOptimisticModuleImport = function _processAsyncOptimisticModuleImport(operationLoader, moduleImportPayload) {
+    var _this7 = this;
+
+    operationLoader.load(moduleImportPayload.operationReference).then(function (operation) {
+      if (operation == null || _this7._state !== 'started') {
+        return;
+      }
+
+      var moduleImportOptimisitcUpdates = _this7._processOptimisticModuleImport(operation, moduleImportPayload);
+
+      moduleImportOptimisitcUpdates.forEach(function (update) {
+        return _this7._publishQueue.applyUpdate(update);
+      });
+
+      if (_this7._optimisticUpdates == null) {
+        process.env.NODE_ENV !== "production" ? warning(false, 'RelayModernQueryExecutor: Unexpected ModuleImport optimisitc ' + 'update in operation %s.' + _this7._operation.request.node.params.name) : void 0;
+      } else {
+        var _this$_optimisticUpda;
+
+        (_this$_optimisticUpda = _this7._optimisticUpdates).push.apply(_this$_optimisticUpda, (0, _toConsumableArray2["default"])(moduleImportOptimisitcUpdates));
+
+        _this7._publishQueue.run();
+      }
+    });
+  };
+
+  _proto._processResponses = function _processResponses(responses) {
+    var _this8 = this;
 
     if (this._optimisticUpdates !== null) {
       this._optimisticUpdates.forEach(function (update) {
-        return _this6._publishQueue.revertUpdate(update);
+        return _this8._publishQueue.revertUpdate(update);
       });
 
       this._optimisticUpdates = null;
     }
 
-    var payload = normalizeResponse(response, this._operation.root, ROOT_TYPE, {
-      getDataID: this._getDataID,
-      path: [],
-      request: this._operation.request
-    });
     this._incrementalPayloadsPending = false;
 
     this._incrementalResults.clear();
 
     this._source.clear();
 
-    this._publishQueue.commitPayload(this._operation, payload, this._updater);
-
-    var updatedOwners = this._publishQueue.run();
+    return responses.map(function (payloadPart) {
+      var relayPayload = normalizeResponse(payloadPart, _this8._operation.root, ROOT_TYPE, {
+        getDataID: _this8._getDataID,
+        treatMissingFieldsAsNull: _this8._treatMissingFieldsAsNull,
+        path: [],
+        request: _this8._operation.request
+      });
 
-    this._updateOperationTracker(updatedOwners);
+      _this8._publishQueue.commitPayload(_this8._operation, relayPayload, _this8._updater);
 
-    this._processPayloadFollowups(payload);
+      return relayPayload;
+    });
   }
   /**
    * Handles any follow-up actions for a Relay payload for @match, @defer,
@@ -394,47 +590,67 @@ function () {
    */
   ;
 
-  _proto._processPayloadFollowups = function _processPayloadFollowups(payload) {
-    var _this7 = this;
+  _proto._processPayloadFollowups = function _processPayloadFollowups(payloads) {
+    var _this9 = this;
 
     if (this._state === 'completed') {
       return;
     }
 
-    var incrementalPlaceholders = payload.incrementalPlaceholders,
-        moduleImportPayloads = payload.moduleImportPayloads;
+    payloads.forEach(function (payload) {
+      var incrementalPlaceholders = payload.incrementalPlaceholders,
+          moduleImportPayloads = payload.moduleImportPayloads,
+          isFinal = payload.isFinal;
+      _this9._state = isFinal ? 'loading_final' : 'loading_incremental';
 
-    if (moduleImportPayloads && moduleImportPayloads.length !== 0) {
-      var operationLoader = this._operationLoader;
-      !operationLoader ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;
-      moduleImportPayloads.forEach(function (moduleImportPayload) {
-        _this7._processModuleImportPayload(moduleImportPayload, operationLoader);
-      });
-    }
+      _this9._updateActiveState();
 
-    if (incrementalPlaceholders && incrementalPlaceholders.length !== 0) {
-      this._incrementalPayloadsPending = this._state !== 'loading_final';
-      incrementalPlaceholders.forEach(function (incrementalPlaceholder) {
-        _this7._processIncrementalPlaceholder(payload, incrementalPlaceholder);
-      });
+      if (isFinal) {
+        _this9._incrementalPayloadsPending = false;
+      }
 
-      if (this._state === 'loading_final') {
-        // The query has defer/stream selections that are enabled, but the
-        // server indicated that this is a "final" payload: no incremental
-        // payloads will be delivered. Warn that the query was (likely) executed
-        // on the server in non-streaming mode, with incremental delivery
-        // disabled.
-        process.env.NODE_ENV !== "production" ? warning(false, 'RelayModernEnvironment: Operation `%s` contains @defer/@stream ' + 'directives but was executed in non-streaming mode. See ' + 'https://fburl.com/relay-incremental-delivery-non-streaming-warning.', this._operation.request.node.params.name) : void 0; // But eagerly process any deferred payloads
-
-        incrementalPlaceholders.forEach(function (placeholder) {
-          if (placeholder.kind === 'defer') {
-            _this7._processDeferResponse(placeholder.label, placeholder.path, placeholder, {
-              data: placeholder.data
-            });
-          }
+      if (moduleImportPayloads && moduleImportPayloads.length !== 0) {
+        var operationLoader = _this9._operationLoader;
+        !operationLoader ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;
+        moduleImportPayloads.forEach(function (moduleImportPayload) {
+          _this9._processModuleImportPayload(moduleImportPayload, operationLoader);
         });
       }
-    }
+
+      if (incrementalPlaceholders && incrementalPlaceholders.length !== 0) {
+        _this9._incrementalPayloadsPending = _this9._state !== 'loading_final';
+        incrementalPlaceholders.forEach(function (incrementalPlaceholder) {
+          _this9._processIncrementalPlaceholder(payload, incrementalPlaceholder);
+        });
+
+        if (_this9._isClientPayload || _this9._state === 'loading_final') {
+          // The query has defer/stream selections that are enabled, but either
+          // the server indicated that this is a "final" payload: no incremental
+          // payloads will be delivered, then warn that the query was (likely)
+          // executed on the server in non-streaming mode, with incremental
+          // delivery disabled; or this is a client payload, and there will be
+          // no incremental payload.
+          process.env.NODE_ENV !== "production" ? warning(_this9._isClientPayload, 'RelayModernEnvironment: Operation `%s` contains @defer/@stream ' + 'directives but was executed in non-streaming mode. See ' + 'https://fburl.com/relay-incremental-delivery-non-streaming-warning.', _this9._operation.request.node.params.name) : void 0; // But eagerly process any deferred payloads
+
+          var relayPayloads = [];
+          incrementalPlaceholders.forEach(function (placeholder) {
+            if (placeholder.kind === 'defer') {
+              relayPayloads.push(_this9._processDeferResponse(placeholder.label, placeholder.path, placeholder, {
+                data: placeholder.data
+              }));
+            }
+          });
+
+          if (relayPayloads.length > 0) {
+            var updatedOwners = _this9._publishQueue.run();
+
+            _this9._updateOperationTracker(updatedOwners);
+
+            _this9._processPayloadFollowups(relayPayloads);
+          }
+        }
+      }
+    });
   };
 
   _proto._maybeCompleteSubscriptionOperationTracking = function _maybeCompleteSubscriptionOperationTracking() {
@@ -458,7 +674,7 @@ function () {
   ;
 
   _proto._processModuleImportPayload = function _processModuleImportPayload(moduleImportPayload, operationLoader) {
-    var _this8 = this;
+    var _this10 = this;
 
     var syncOperation = operationLoader.get(moduleImportPayload.operationReference);
 
@@ -466,9 +682,9 @@ function () {
       // If the operation module is available synchronously, normalize the
       // data synchronously.
       this._schedule(function () {
-        _this8._handleModuleImportPayload(moduleImportPayload, syncOperation);
+        _this10._handleModuleImportPayload(moduleImportPayload, syncOperation);
 
-        _this8._maybeCompleteSubscriptionOperationTracking();
+        _this10._maybeCompleteSubscriptionOperationTracking();
       });
     } else {
       // Otherwise load the operation module and schedule a task to normalize
@@ -478,9 +694,9 @@ function () {
       this._pendingModulePayloadsCount++;
 
       var decrementPendingCount = function decrementPendingCount() {
-        _this8._pendingModulePayloadsCount--;
+        _this10._pendingModulePayloadsCount--;
 
-        _this8._maybeCompleteSubscriptionOperationTracking();
+        _this10._maybeCompleteSubscriptionOperationTracking();
       }; // Observable.from(operationLoader.load()) wouldn't catch synchronous
       // errors thrown by the load function, which is user-defined. Guard
       // against that with Observable.from(new Promise(<work>)).
@@ -490,37 +706,30 @@ function () {
         operationLoader.load(moduleImportPayload.operationReference).then(resolve, reject);
       })).map(function (operation) {
         if (operation != null) {
-          _this8._schedule(function () {
-            _this8._handleModuleImportPayload(moduleImportPayload, operation);
+          _this10._schedule(function () {
+            _this10._handleModuleImportPayload(moduleImportPayload, operation);
           });
         }
       }).subscribe({
         complete: function complete() {
-          _this8._complete(_id3);
+          _this10._complete(_id3);
 
           decrementPendingCount();
         },
         error: function error(_error4) {
-          _this8._error(_error4);
+          _this10._error(_error4);
 
           decrementPendingCount();
         },
         start: function start(subscription) {
-          return _this8._start(_id3, subscription);
+          return _this10._start(_id3, subscription);
         }
       });
     }
   };
 
   _proto._handleModuleImportPayload = function _handleModuleImportPayload(moduleImportPayload, operation) {
-    var selector = createNormalizationSelector(operation, moduleImportPayload.dataID, moduleImportPayload.variables);
-    var relayPayload = normalizeResponse({
-      data: moduleImportPayload.data
-    }, selector, moduleImportPayload.typeName, {
-      getDataID: this._getDataID,
-      path: moduleImportPayload.path,
-      request: this._operation.request
-    });
+    var relayPayload = this._normalizeModuleImport(moduleImportPayload, operation);
 
     this._publishQueue.commitPayload(this._operation, relayPayload);
 
@@ -528,7 +737,7 @@ function () {
 
     this._updateOperationTracker(updatedOwners);
 
-    this._processPayloadFollowups(relayPayload);
+    this._processPayloadFollowups([relayPayload]);
   }
   /**
    * The executor now knows that GraphQL responses are expected for a given
@@ -544,7 +753,7 @@ function () {
   ;
 
   _proto._processIncrementalPlaceholder = function _processIncrementalPlaceholder(relayPayload, placeholder) {
-    var _this9 = this;
+    var _this11 = this;
 
     var _relayPayload$fieldPa;
 
@@ -572,9 +781,9 @@ function () {
 
     var parentID;
 
-    if (placeholder.kind === 'stream' || placeholder.kind === 'connection_edge') {
+    if (placeholder.kind === 'stream') {
       parentID = placeholder.parentID;
-    } else if (placeholder.kind === 'defer' || placeholder.kind === 'connection_page_info') {
+    } else if (placeholder.kind === 'defer') {
       parentID = placeholder.selector.dataID;
     } else {
       placeholder;
@@ -625,10 +834,14 @@ function () {
 
 
     if (pendingResponses != null) {
-      pendingResponses.forEach(function (incrementalResponse) {
-        _this9._schedule(function () {
-          _this9._processIncrementalResponse(incrementalResponse);
-        });
+      this._schedule(function () {
+        var payloadFollowups = _this11._processIncrementalResponses(pendingResponses);
+
+        var updatedOwners = _this11._publishQueue.run();
+
+        _this11._updateOperationTracker(updatedOwners);
+
+        _this11._processPayloadFollowups(payloadFollowups);
       });
     }
   }
@@ -639,131 +852,70 @@ function () {
    */
   ;
 
-  _proto._processIncrementalResponse = function _processIncrementalResponse(incrementalResponse) {
-    var label = incrementalResponse.label,
-        path = incrementalResponse.path,
-        response = incrementalResponse.response;
+  _proto._processIncrementalResponses = function _processIncrementalResponses(incrementalResponses) {
+    var _this12 = this;
 
-    var resultForLabel = this._incrementalResults.get(label);
+    var relayPayloads = [];
+    incrementalResponses.forEach(function (incrementalResponse) {
+      var label = incrementalResponse.label,
+          path = incrementalResponse.path,
+          response = incrementalResponse.response;
 
-    if (resultForLabel == null) {
-      resultForLabel = new Map();
+      var resultForLabel = _this12._incrementalResults.get(label);
 
-      this._incrementalResults.set(label, resultForLabel);
-    }
+      if (resultForLabel == null) {
+        resultForLabel = new Map();
 
-    if (label.indexOf('$defer$') !== -1) {
-      var pathKey = path.map(String).join('.');
-      var resultForPath = resultForLabel.get(pathKey);
-
-      if (resultForPath == null) {
-        resultForPath = {
-          kind: 'response',
-          responses: [incrementalResponse]
-        };
-        resultForLabel.set(pathKey, resultForPath);
-        return;
-      } else if (resultForPath.kind === 'response') {
-        resultForPath.responses.push(incrementalResponse);
-        return;
+        _this12._incrementalResults.set(label, resultForLabel);
       }
 
-      var placeholder = resultForPath.placeholder;
+      if (label.indexOf('$defer$') !== -1) {
+        var pathKey = path.map(String).join('.');
+        var resultForPath = resultForLabel.get(pathKey);
+
+        if (resultForPath == null) {
+          resultForPath = {
+            kind: 'response',
+            responses: [incrementalResponse]
+          };
+          resultForLabel.set(pathKey, resultForPath);
+          return;
+        } else if (resultForPath.kind === 'response') {
+          resultForPath.responses.push(incrementalResponse);
+          return;
+        }
 
-      if (placeholder.kind === 'connection_page_info') {
-        this._processConnectionPageInfoResponse(label, path, placeholder, response);
-      } else {
+        var placeholder = resultForPath.placeholder;
         !(placeholder.kind === 'defer') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' + 'to be data for @defer, was `@%s`.', pathKey, label, placeholder.kind) : invariant(false) : void 0;
-
-        this._processDeferResponse(label, path, placeholder, response);
-      }
-    } else {
-      // @stream payload path values end in the field name and item index,
-      // but Relay records paths relative to the parent of the stream node:
-      // therefore we strip the last two elements just to lookup the path
-      // (the item index is used later to insert the element in the list)
-      var _pathKey = path.slice(0, -2).map(String).join('.');
-
-      var _resultForPath = resultForLabel.get(_pathKey);
-
-      if (_resultForPath == null) {
-        _resultForPath = {
-          kind: 'response',
-          responses: [incrementalResponse]
-        };
-        resultForLabel.set(_pathKey, _resultForPath);
-        return;
-      } else if (_resultForPath.kind === 'response') {
-        _resultForPath.responses.push(incrementalResponse);
-
-        return;
-      }
-
-      var _placeholder = _resultForPath.placeholder;
-
-      if (_placeholder.kind === 'connection_edge') {
-        this._processConnectionEdgeResponse(label, path, _placeholder, response);
+        relayPayloads.push(_this12._processDeferResponse(label, path, placeholder, response));
       } else {
-        !(_placeholder.kind === 'stream') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' + 'to be data for @stream, was `@%s`.', _pathKey, label, _placeholder.kind) : invariant(false) : void 0;
+        // @stream payload path values end in the field name and item index,
+        // but Relay records paths relative to the parent of the stream node:
+        // therefore we strip the last two elements just to lookup the path
+        // (the item index is used later to insert the element in the list)
+        var _pathKey = path.slice(0, -2).map(String).join('.');
+
+        var _resultForPath = resultForLabel.get(_pathKey);
+
+        if (_resultForPath == null) {
+          _resultForPath = {
+            kind: 'response',
+            responses: [incrementalResponse]
+          };
+          resultForLabel.set(_pathKey, _resultForPath);
+          return;
+        } else if (_resultForPath.kind === 'response') {
+          _resultForPath.responses.push(incrementalResponse);
+
+          return;
+        }
 
-        this._processStreamResponse(label, path, _placeholder, response);
+        var _placeholder = _resultForPath.placeholder;
+        !(_placeholder.kind === 'stream') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' + 'to be data for @stream, was `@%s`.', _pathKey, label, _placeholder.kind) : invariant(false) : void 0;
+        relayPayloads.push(_this12._processStreamResponse(label, path, _placeholder, response));
       }
-    }
-  };
-
-  _proto._processConnectionPageInfoResponse = function _processConnectionPageInfoResponse(label, path, placeholder, response) {
-    var _relayPayload$connect;
-
-    var relayPayload = normalizeResponse(response, placeholder.selector, placeholder.typeName, {
-      getDataID: this._getDataID,
-      path: placeholder.path,
-      request: this._operation.request
     });
-
-    var _RelayConnectionInter = RelayConnectionInterface.get(),
-        END_CURSOR = _RelayConnectionInter.END_CURSOR,
-        HAS_NEXT_PAGE = _RelayConnectionInter.HAS_NEXT_PAGE,
-        HAS_PREV_PAGE = _RelayConnectionInter.HAS_PREV_PAGE,
-        PAGE_INFO = _RelayConnectionInter.PAGE_INFO,
-        START_CURSOR = _RelayConnectionInter.START_CURSOR;
-
-    var pageRecord = relayPayload.source.get(placeholder.selector.dataID);
-    var pageInfoID = pageRecord != null ? RelayModernRecord.getLinkedRecordID(pageRecord, PAGE_INFO) : null;
-    var pageInfoRecord = pageInfoID != null ? relayPayload.source.get(pageInfoID) : null;
-    var endCursor;
-    var hasNextPage;
-    var hasPrevPage;
-    var startCursor;
-
-    if (pageInfoRecord != null) {
-      endCursor = RelayModernRecord.getValue(pageInfoRecord, END_CURSOR);
-      hasNextPage = RelayModernRecord.getValue(pageInfoRecord, HAS_NEXT_PAGE);
-      hasPrevPage = RelayModernRecord.getValue(pageInfoRecord, HAS_PREV_PAGE);
-      startCursor = RelayModernRecord.getValue(pageInfoRecord, START_CURSOR);
-    }
-
-    relayPayload = (0, _objectSpread2["default"])({}, relayPayload, {
-      connectionEvents: ((_relayPayload$connect = relayPayload.connectionEvents) !== null && _relayPayload$connect !== void 0 ? _relayPayload$connect : []).concat({
-        kind: 'stream.pageInfo',
-        args: placeholder.args,
-        connectionID: placeholder.connectionID,
-        pageInfo: {
-          endCursor: typeof endCursor === 'string' ? endCursor : null,
-          startCursor: typeof startCursor === 'string' ? startCursor : null,
-          hasNextPage: typeof hasNextPage === 'boolean' ? hasNextPage : null,
-          hasPrevPage: typeof hasPrevPage === 'boolean' ? hasPrevPage : null
-        },
-        request: this._operation.request
-      })
-    });
-
-    this._publishQueue.commitPayload(this._operation, relayPayload);
-
-    var updatedOwners = this._publishQueue.run();
-
-    this._updateOperationTracker(updatedOwners);
-
-    this._processPayloadFollowups(relayPayload);
+    return relayPayloads;
   };
 
   _proto._processDeferResponse = function _processDeferResponse(label, path, placeholder, response) {
@@ -771,7 +923,8 @@ function () {
     var relayPayload = normalizeResponse(response, placeholder.selector, placeholder.typeName, {
       getDataID: this._getDataID,
       path: placeholder.path,
-      request: this._operation.request
+      request: this._operation.request,
+      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull
     });
 
     this._publishQueue.commitPayload(this._operation, relayPayload); // Load the version of the parent record from which this incremental data
@@ -784,55 +937,21 @@ function () {
     var fieldPayloads = parentEntry.fieldPayloads;
 
     if (fieldPayloads.length !== 0) {
+      var _response$extensions2;
+
       var handleFieldsRelayPayload = {
-        connectionEvents: null,
         errors: null,
         fieldPayloads: fieldPayloads,
         incrementalPlaceholders: null,
         moduleImportPayloads: null,
-        source: RelayRecordSource.create()
+        source: RelayRecordSource.create(),
+        isFinal: ((_response$extensions2 = response.extensions) === null || _response$extensions2 === void 0 ? void 0 : _response$extensions2.is_final) === true
       };
 
       this._publishQueue.commitPayload(this._operation, handleFieldsRelayPayload);
     }
 
-    var updatedOwners = this._publishQueue.run();
-
-    this._updateOperationTracker(updatedOwners);
-
-    this._processPayloadFollowups(relayPayload);
-  };
-
-  _proto._processConnectionEdgeResponse = function _processConnectionEdgeResponse(label, path, placeholder, response) {
-    var _relayPayload$connect2;
-
-    var parentID = placeholder.parentID,
-        node = placeholder.node,
-        variables = placeholder.variables;
-
-    var _this$_normalizeStrea = this._normalizeStreamItem(response, parentID, node, variables, path, placeholder.path),
-        relayPayload = _this$_normalizeStrea.relayPayload,
-        itemID = _this$_normalizeStrea.itemID,
-        itemIndex = _this$_normalizeStrea.itemIndex;
-
-    relayPayload = (0, _objectSpread2["default"])({}, relayPayload, {
-      connectionEvents: ((_relayPayload$connect2 = relayPayload.connectionEvents) !== null && _relayPayload$connect2 !== void 0 ? _relayPayload$connect2 : []).concat({
-        kind: 'stream.edge',
-        args: placeholder.args,
-        connectionID: placeholder.connectionID,
-        edgeID: itemID,
-        index: itemIndex,
-        request: this._operation.request
-      })
-    });
-
-    this._publishQueue.commitPayload(this._operation, relayPayload);
-
-    var updatedOwners = this._publishQueue.run();
-
-    this._updateOperationTracker(updatedOwners);
-
-    this._processPayloadFollowups(relayPayload);
+    return relayPayload;
   }
   /**
    * Process the data for one item in a @stream field.
@@ -847,13 +966,13 @@ function () {
     var field = node.selections[0];
     !(field != null && field.kind === 'LinkedField' && field.plural === true) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernEnvironment: Expected @stream to be used on a plural field.') : invariant(false) : void 0;
 
-    var _this$_normalizeStrea2 = this._normalizeStreamItem(response, parentID, field, variables, path, placeholder.path),
-        fieldPayloads = _this$_normalizeStrea2.fieldPayloads,
-        itemID = _this$_normalizeStrea2.itemID,
-        itemIndex = _this$_normalizeStrea2.itemIndex,
-        prevIDs = _this$_normalizeStrea2.prevIDs,
-        relayPayload = _this$_normalizeStrea2.relayPayload,
-        storageKey = _this$_normalizeStrea2.storageKey; // Publish the new item and update the parent record to set
+    var _this$_normalizeStrea = this._normalizeStreamItem(response, parentID, field, variables, path, placeholder.path),
+        fieldPayloads = _this$_normalizeStrea.fieldPayloads,
+        itemID = _this$_normalizeStrea.itemID,
+        itemIndex = _this$_normalizeStrea.itemIndex,
+        prevIDs = _this$_normalizeStrea.prevIDs,
+        relayPayload = _this$_normalizeStrea.relayPayload,
+        storageKey = _this$_normalizeStrea.storageKey; // Publish the new item and update the parent record to set
     // field[index] = item *if* the parent record hasn't been concurrently
     // modified.
 
@@ -892,22 +1011,18 @@ function () {
 
     if (fieldPayloads.length !== 0) {
       var handleFieldsRelayPayload = {
-        connectionEvents: null,
         errors: null,
         fieldPayloads: fieldPayloads,
         incrementalPlaceholders: null,
         moduleImportPayloads: null,
-        source: RelayRecordSource.create()
+        source: RelayRecordSource.create(),
+        isFinal: false
       };
 
       this._publishQueue.commitPayload(this._operation, handleFieldsRelayPayload);
     }
 
-    var updatedOwners = this._publishQueue.run();
-
-    this._updateOperationTracker(updatedOwners);
-
-    this._processPayloadFollowups(relayPayload);
+    return relayPayload;
   };
 
   _proto._normalizeStreamItem = function _normalizeStreamItem(response, parentID, field, variables, path, normalizationPath) {
@@ -960,7 +1075,8 @@ function () {
     var relayPayload = normalizeResponse(response, selector, typeName, {
       getDataID: this._getDataID,
       path: [].concat((0, _toConsumableArray2["default"])(normalizationPath), [responseKey, String(itemIndex)]),
-      request: this._operation.request
+      request: this._operation.request,
+      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull
     });
     return {
       fieldPayloads: fieldPayloads,
@@ -987,15 +1103,42 @@ function () {
   return Executor;
 }();
 
+function partitionGraphQLResponses(responses) {
+  var nonIncrementalResponses = [];
+  var incrementalResponses = [];
+  responses.forEach(function (response) {
+    if (response.path != null || response.label != null) {
+      var label = response.label,
+          path = response.path;
+
+      if (label == null || path == null) {
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayModernQueryExecutor: invalid incremental payload, expected ' + '`path` and `label` to either both be null/undefined, or ' + '`path` to be an `Array<string | number>` and `label` to be a ' + '`string`.') : invariant(false) : void 0;
+      }
+
+      incrementalResponses.push({
+        label: label,
+        path: path,
+        response: response
+      });
+    } else {
+      nonIncrementalResponses.push(response);
+    }
+  });
+  return [nonIncrementalResponses, incrementalResponses];
+}
+
 function normalizeResponse(response, selector, typeName, options) {
+  var _response$extensions3;
+
   var data = response.data,
       errors = response.errors;
   var source = RelayRecordSource.create();
   var record = RelayModernRecord.create(selector.dataID, typeName);
   source.set(selector.dataID, record);
   var relayPayload = RelayResponseNormalizer.normalize(source, selector, data, options);
-  return (0, _objectSpread2["default"])({}, relayPayload, {
-    errors: errors
+  return _objectSpread({}, relayPayload, {
+    errors: errors,
+    isFinal: ((_response$extensions3 = response.extensions) === null || _response$extensions3 === void 0 ? void 0 : _response$extensions3.is_final) === true
   });
 }