relay-runtime 11.0.1 → 13.0.0-rc.1

package/lib/mutations/RelayRecordProxy.js

@@ -10,20 +10,21 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('../store/ClientID'),
     generateClientID = _require.generateClientID;
 
 var _require2 = require('../store/RelayStoreUtils'),
     getStableStorageKey = _require2.getStableStorageKey;
 
+var invariant = require('invariant');
 /**
  * @internal
  *
  * A helper class for manipulating a given record from a record source via an
  * imperative/OO-style API.
  */
+
+
 var RelayRecordProxy = /*#__PURE__*/function () {
   function RelayRecordProxy(source, mutator, dataID) {
     this._dataID = dataID;

package/lib/mutations/RelayRecordSourceMutator.js

@@ -12,11 +12,10 @@
 
 var RelayModernRecord = require('../store/RelayModernRecord');
 
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('../store/RelayRecordState'),
     EXISTENT = _require.EXISTENT;
 
+var invariant = require('invariant');
 /**
  * @internal
  *
@@ -29,6 +28,8 @@ var _require = require('../store/RelayRecordState'),
  * - Modifications cause a fresh version of a record to be created in `sink`.
  *   These sink records contain only modified fields.
  */
+
+
 var RelayRecordSourceMutator = /*#__PURE__*/function () {
   function RelayRecordSourceMutator(base, sink) {
     this.__sources = [sink, base];

package/lib/mutations/RelayRecordSourceProxy.js

@@ -12,10 +12,6 @@
 
 var RelayModernRecord = require('../store/RelayModernRecord');
 
-var RelayRecordProxy = require('./RelayRecordProxy');
-
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('../store/RelayRecordState'),
     EXISTENT = _require.EXISTENT,
     NONEXISTENT = _require.NONEXISTENT;
@@ -24,11 +20,19 @@ var _require2 = require('../store/RelayStoreUtils'),
     ROOT_ID = _require2.ROOT_ID,
     ROOT_TYPE = _require2.ROOT_TYPE;
 
+var _require3 = require('./readUpdatableQuery_EXPERIMENTAL'),
+    _readUpdatableQuery_EXPERIMENTAL = _require3.readUpdatableQuery_EXPERIMENTAL;
+
+var RelayRecordProxy = require('./RelayRecordProxy');
+
+var invariant = require('invariant');
 /**
  * @internal
  *
  * A helper for manipulating a `RecordSource` via an imperative/OO-style API.
  */
+
+
 var RelayRecordSourceProxy = /*#__PURE__*/function () {
   function RelayRecordSourceProxy(mutator, getDataID, handlerProvider) {
     this.__mutator = mutator;
@@ -131,6 +135,10 @@ var RelayRecordSourceProxy = /*#__PURE__*/function () {
     return this._idsMarkedForInvalidation;
   };
 
+  _proto.readUpdatableQuery_EXPERIMENTAL = function readUpdatableQuery_EXPERIMENTAL(query, variables) {
+    return _readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  };
+
   return RelayRecordSourceProxy;
 }();
 

package/lib/mutations/RelayRecordSourceSelectorProxy.js

@@ -10,12 +10,14 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('../store/RelayStoreUtils'),
-    getStorageKey = _require.getStorageKey,
-    ROOT_TYPE = _require.ROOT_TYPE;
+    ROOT_TYPE = _require.ROOT_TYPE,
+    getStorageKey = _require.getStorageKey;
+
+var _require2 = require('./readUpdatableQuery_EXPERIMENTAL'),
+    _readUpdatableQuery_EXPERIMENTAL = _require2.readUpdatableQuery_EXPERIMENTAL;
 
+var invariant = require('invariant');
 /**
  * @internal
  *
@@ -24,6 +26,8 @@ var _require = require('../store/RelayStoreUtils'),
  * complex arguments and it can be tedious to re-construct the correct sets of
  * arguments to pass to e.g. `getRoot().getLinkedRecord()`.
  */
+
+
 var RelayRecordSourceSelectorProxy = /*#__PURE__*/function () {
   function RelayRecordSourceSelectorProxy(mutator, recordSource, readSelector) {
     this.__mutator = mutator;
@@ -61,8 +65,13 @@ var RelayRecordSourceSelectorProxy = /*#__PURE__*/function () {
 
   _proto._getRootField = function _getRootField(selector, fieldName, plural) {
     var field = selector.node.selections.find(function (selection) {
-      return selection.kind === 'LinkedField' && selection.name === fieldName;
+      return selection.kind === 'LinkedField' && selection.name === fieldName || selection.kind === 'RequiredField' && selection.field.name === fieldName;
     });
+
+    if (field && field.kind === 'RequiredField') {
+      field = field.field;
+    }
+
     !(field && field.kind === 'LinkedField') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayRecordSourceSelectorProxy#getRootField(): Cannot find root ' + 'field `%s`, no such field is defined on GraphQL document `%s`.', fieldName, selector.node.name) : invariant(false) : void 0;
     !(field.plural === plural) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayRecordSourceSelectorProxy#getRootField(): Expected root field ' + '`%s` to be %s.', fieldName, plural ? 'plural' : 'singular') : invariant(false) : void 0;
     return field;
@@ -86,6 +95,10 @@ var RelayRecordSourceSelectorProxy = /*#__PURE__*/function () {
     this.__recordSource.invalidateStore();
   };
 
+  _proto.readUpdatableQuery_EXPERIMENTAL = function readUpdatableQuery_EXPERIMENTAL(query, variables) {
+    return _readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  };
+
   return RelayRecordSourceSelectorProxy;
 }();
 

package/lib/mutations/applyOptimisticMutation.js

@@ -10,18 +10,18 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
-
-var invariant = require("fbjs/lib/invariant");
-
-var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
-
 var _require = require('../query/GraphQLTag'),
     getRequest = _require.getRequest;
 
+var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
+
 var _require2 = require('../store/RelayModernOperationDescriptor'),
     createOperationDescriptor = _require2.createOperationDescriptor;
 
+var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
+
+var invariant = require('invariant');
+
 /**
  * Higher-level helper function to execute a mutation against a specific
  * environment.

package/lib/mutations/commitMutation.js

@@ -14,25 +14,25 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
-var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
-
-var invariant = require("fbjs/lib/invariant");
-
-var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
-
-var validateMutation = require('./validateMutation');
-
-var warning = require("fbjs/lib/warning");
-
 var _require = require('../query/GraphQLTag'),
     getRequest = _require.getRequest;
 
 var _require2 = require('../store/ClientID'),
     generateUniqueClientID = _require2.generateUniqueClientID;
 
+var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
+
 var _require3 = require('../store/RelayModernOperationDescriptor'),
     createOperationDescriptor = _require3.createOperationDescriptor;
 
+var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
+
+var validateMutation = require('./validateMutation');
+
+var invariant = require('invariant');
+
+var warning = require("fbjs/lib/warning");
+
 /**
  * Higher-level helper function to execute a mutation against a specific
  * environment.
@@ -87,6 +87,8 @@ function commitMutation(environment, config) {
     uploadables: uploadables
   }).subscribe({
     next: function next(payload) {
+      var _config$onNext;
+
       if (Array.isArray(payload)) {
         payload.forEach(function (item) {
           if (item.errors) {
@@ -98,6 +100,8 @@ function commitMutation(environment, config) {
           errors.push.apply(errors, (0, _toConsumableArray2["default"])(payload.errors));
         }
       }
+
+      (_config$onNext = config.onNext) === null || _config$onNext === void 0 ? void 0 : _config$onNext.call(config);
     },
     complete: function complete() {
       var onCompleted = config.onCompleted;

package/lib/mutations/readUpdatableQuery_EXPERIMENTAL.js

@@ -0,0 +1,238 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @emails oncall+relay
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _require = require('../query/GraphQLTag'),
+    getRequest = _require.getRequest;
+
+var _require2 = require('../store/RelayStoreUtils'),
+    getArgumentValues = _require2.getArgumentValues;
+
+var nonUpdatableKeys = ['id', '__id', '__typename'];
+
+function readUpdatableQuery_EXPERIMENTAL(query, variables, proxy) {
+  // TODO assert that the concrete request is an updatable query
+  var request = getRequest(query);
+  var updatableProxy = {};
+  updateProxyFromSelections(updatableProxy, proxy.getRoot(), variables, request.fragment.selections, proxy);
+
+  if (process.env.NODE_ENV !== "production") {
+    Object.freeze(updatableProxy);
+  }
+
+  return updatableProxy;
+}
+
+function updateProxyFromSelections(mutableUpdatableProxy, recordProxy, queryVariables, selections, root) {
+  var _selection$alias, _selection$alias2;
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(selections),
+      _step;
+
+  try {
+    var _loop = function _loop() {
+      var selection = _step.value;
+
+      switch (selection.kind) {
+        case 'LinkedField':
+          // Linked fields are assignable if they contain fragment spreads or
+          // read-only otherwise.
+          var isAssignable = selection.selections.some(function (item) {
+            return item.kind === 'FragmentSpread';
+          });
+          var set = !isAssignable ? undefined : selection.plural ? createSetterForPluralLinkedField(selection, queryVariables, recordProxy, root) : createSetterForSingularLinkedField(selection, queryVariables, recordProxy, root);
+          var get = selection.plural ? createGetterForPluralLinkedField(selection, queryVariables, recordProxy, root) : createGetterForSingularLinkedField(selection, queryVariables, recordProxy, root);
+          Object.defineProperty(mutableUpdatableProxy, (_selection$alias = selection.alias) !== null && _selection$alias !== void 0 ? _selection$alias : selection.name, {
+            get: get,
+            set: set
+          });
+          break;
+
+        case 'ScalarField':
+          var scalarFieldName = (_selection$alias2 = selection.alias) !== null && _selection$alias2 !== void 0 ? _selection$alias2 : selection.name;
+          Object.defineProperty(mutableUpdatableProxy, scalarFieldName, {
+            get: function get() {
+              var _selection$args;
+
+              var variables = getArgumentValues((_selection$args = selection.args) !== null && _selection$args !== void 0 ? _selection$args : [], queryVariables); // Flow incorrect assumes that the return value for the get method must match
+              // the set parameter.
+
+              return recordProxy.getValue(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+              variables // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+              );
+            },
+            set: nonUpdatableKeys.includes(selection.name) ? undefined : // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+            function (newValue) {
+              var _selection$args2;
+
+              var variables = getArgumentValues((_selection$args2 = selection.args) !== null && _selection$args2 !== void 0 ? _selection$args2 : [], queryVariables);
+              recordProxy.setValue(newValue, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+              variables);
+            }
+          });
+          break;
+
+        case 'InlineFragment':
+          if (recordProxy.getType() === selection.type) {
+            updateProxyFromSelections(mutableUpdatableProxy, recordProxy, queryVariables, selection.selections, root);
+          }
+
+          break;
+
+        case 'FragmentSpread':
+          // Explicitly ignore
+          break;
+
+        default:
+          throw new Error('Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.');
+      }
+    };
+
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function createSetterForPluralLinkedField(selection, queryVariables, recordProxy, root) {
+  return function set(newValue) {
+    var _selection$args3;
+
+    var variables = getArgumentValues((_selection$args3 = selection.args) !== null && _selection$args3 !== void 0 ? _selection$args3 : [], queryVariables);
+
+    if (newValue == null) {
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      recordProxy.setValue(null, selection.name, variables);
+    } else {
+      var recordProxies = newValue.map(function (item) {
+        if (item == null) {
+          throw new Error('When assigning an array of items, none of the items should be null or undefined.');
+        }
+
+        var __id = item.__id;
+
+        if (__id == null) {
+          throw new Error('The __id field must be present on each item passed to the setter. This indicates a bug in Relay.');
+        }
+
+        var newValueRecord = root.get(__id);
+
+        if (newValueRecord == null) {
+          throw new Error("Did not find item with data id ".concat(__id, " in the store."));
+        }
+
+        return newValueRecord;
+      });
+      recordProxy.setLinkedRecords(recordProxies, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+      variables);
+    }
+  };
+}
+
+function createSetterForSingularLinkedField(selection, queryVariables, recordProxy, root) {
+  return function set(newValue) {
+    var _selection$args4;
+
+    var variables = getArgumentValues((_selection$args4 = selection.args) !== null && _selection$args4 !== void 0 ? _selection$args4 : [], queryVariables);
+
+    if (newValue == null) {
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      recordProxy.setValue(null, selection.name, variables);
+    } else {
+      var __id = newValue.__id;
+
+      if (__id == null) {
+        throw new Error('The __id field must be present on the argument. This indicates a bug in Relay.');
+      }
+
+      var newValueRecord = root.get(__id);
+
+      if (newValueRecord == null) {
+        throw new Error("Did not find item with data id ".concat(__id, " in the store."));
+      }
+
+      recordProxy.setLinkedRecord(newValueRecord, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+      variables);
+    }
+  };
+}
+
+function createGetterForPluralLinkedField(selection, queryVariables, recordProxy, root) {
+  return function () {
+    var _selection$args5;
+
+    var variables = getArgumentValues((_selection$args5 = selection.args) !== null && _selection$args5 !== void 0 ? _selection$args5 : [], queryVariables);
+    var linkedRecords = recordProxy.getLinkedRecords(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+    variables);
+
+    if (linkedRecords != null) {
+      return linkedRecords.map(function (linkedRecord) {
+        if (linkedRecord != null) {
+          var updatableProxy = {};
+          updateProxyFromSelections(updatableProxy, linkedRecord, queryVariables, selection.selections, root);
+
+          if (process.env.NODE_ENV !== "production") {
+            Object.freeze(updatableProxy);
+          } // Flow incorrect assumes that the return value for the get method must match
+          // the set parameter.
+          // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+
+
+          return updatableProxy;
+        } else {
+          return linkedRecord;
+        } // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+
+      });
+    } else {
+      return linkedRecords;
+    }
+  };
+}
+
+function createGetterForSingularLinkedField(selection, queryVariables, recordProxy, root) {
+  return function () {
+    var _selection$args6;
+
+    var variables = getArgumentValues((_selection$args6 = selection.args) !== null && _selection$args6 !== void 0 ? _selection$args6 : [], queryVariables);
+    var linkedRecord = recordProxy.getLinkedRecord(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+    variables);
+
+    if (linkedRecord != null) {
+      var updatableProxy = {};
+      updateProxyFromSelections(updatableProxy, linkedRecord, queryVariables, selection.selections, root);
+
+      if (process.env.NODE_ENV !== "production") {
+        Object.freeze(updatableProxy);
+      } // Flow incorrect assumes that the return value for the get method must match
+      // the set parameter.
+      // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+
+
+      return updatableProxy;
+    } else {
+      return linkedRecord;
+    }
+  };
+}
+
+module.exports = {
+  readUpdatableQuery_EXPERIMENTAL: readUpdatableQuery_EXPERIMENTAL
+};

package/lib/mutations/validateMutation.js

@@ -14,14 +14,11 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var warning = require("fbjs/lib/warning");
-
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-
 var _require = require('../util/RelayConcreteNode'),
-    CONDITION = _require.CONDITION,
+    ACTOR_CHANGE = _require.ACTOR_CHANGE,
     CLIENT_COMPONENT = _require.CLIENT_COMPONENT,
     CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
+    CONDITION = _require.CONDITION,
     DEFER = _require.DEFER,
     FLIGHT_FIELD = _require.FLIGHT_FIELD,
     FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,
@@ -34,6 +31,11 @@ var _require = require('../util/RelayConcreteNode'),
     STREAM = _require.STREAM,
     TYPE_DISCRIMINATOR = _require.TYPE_DISCRIMINATOR;
 
+var warning = require("fbjs/lib/warning");
+
+// $FlowFixMe[method-unbinding] added when improving typing for this parameters
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
 var validateMutation = function validateMutation() {};
 
 if (process.env.NODE_ENV !== "production") {
@@ -90,6 +92,9 @@ if (process.env.NODE_ENV !== "production") {
       case FLIGHT_FIELD:
         return validateField(optimisticResponse, selection, context);
 
+      case ACTOR_CHANGE:
+        return validateField(optimisticResponse, selection.linkedField, context);
+
       case INLINE_FRAGMENT:
         var type = selection.type;
         var isConcreteType = selection.abstractKey == null;

package/lib/network/ConvertToExecuteFunction.js

@@ -11,10 +11,11 @@
 'use strict';
 
 var RelayObservable = require('./RelayObservable');
-
 /**
  * Converts a FetchFunction into an ExecuteFunction for use by RelayNetwork.
  */
+
+
 function convertFetch(fn) {
   return function fetch(request, variables, cacheConfig, uploadables, logRequestInfo) {
     var result = fn(request, variables, cacheConfig, uploadables, logRequestInfo); // Note: We allow FetchFunction to directly return Error to indicate

package/lib/network/RelayNetwork.js

@@ -10,15 +10,16 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('./ConvertToExecuteFunction'),
     convertFetch = _require.convertFetch;
 
+var invariant = require('invariant');
 /**
  * Creates an implementation of the `Network` interface defined in
  * `RelayNetworkTypes` given `fetch` and `subscribe` functions.
  */
+
+
 function create(fetchFn, subscribe) {
   // Convert to functions that returns RelayObservable.
   var observeFetch = convertFetch(fetchFn);

package/lib/network/RelayQueryResponseCache.js

@@ -14,10 +14,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var invariant = require("fbjs/lib/invariant");
-
 var stableCopy = require('../util/stableCopy');
 
+var invariant = require('invariant');
+
 /**
  * A cache for storing query responses, featuring:
  * - `get` with TTL
@@ -53,12 +53,28 @@ var RelayQueryResponseCache = /*#__PURE__*/function () {
 
     var response = this._responses.get(cacheKey);
 
-    return response != null ? // $FlowFixMe[speculation-ambiguous]
-    (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload), {}, {
+    if (response == null) {
+      return null;
+    }
+
+    if (Array.isArray(response.payload)) {
+      return response.payload.map(function (payload) {
+        return (// $FlowFixMe[incompatible-cast]
+          (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, payload), {}, {
+            extensions: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, payload.extensions), {}, {
+              cacheTimestamp: response.fetchTime
+            })
+          })
+        );
+      });
+    } // $FlowFixMe[incompatible-cast]
+
+
+    return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload), {}, {
       extensions: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload.extensions), {}, {
         cacheTimestamp: response.fetchTime
       })
-    }) : null;
+    });
   };
 
   _proto.set = function set(queryID, variables, payload) {

package/lib/network/wrapNetworkWithLogObserver.js

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var generateID = require('../util/generateID');
+/**
+ * Wraps the network with logging to ensure that network requests are
+ * always logged. Relying on each network callsite to be wrapped is
+ * untenable and will eventually lead to holes in the logging.
+ * NOTE: This function takes an environment instance, because Relay
+ * devtools will mutate the `env.__log` method, and the devtools rely
+ * on it to receive network events.
+ */
+
+
+function wrapNetworkWithLogObserver(env, network) {
+  return {
+    execute: function execute(params, variables, cacheConfig, uploadables) {
+      var networkRequestId = generateID();
+      var logObserver = {
+        start: function start(subscription) {
+          env.__log({
+            name: 'network.start',
+            networkRequestId: networkRequestId,
+            params: params,
+            variables: variables,
+            cacheConfig: cacheConfig
+          });
+        },
+        next: function next(response) {
+          env.__log({
+            name: 'network.next',
+            networkRequestId: networkRequestId,
+            response: response
+          });
+        },
+        error: function error(_error) {
+          env.__log({
+            name: 'network.error',
+            networkRequestId: networkRequestId,
+            error: _error
+          });
+        },
+        complete: function complete() {
+          env.__log({
+            name: 'network.complete',
+            networkRequestId: networkRequestId
+          });
+        },
+        unsubscribe: function unsubscribe() {
+          env.__log({
+            name: 'network.unsubscribe',
+            networkRequestId: networkRequestId
+          });
+        }
+      };
+
+      var logRequestInfo = function logRequestInfo(info) {
+        env.__log({
+          name: 'network.info',
+          networkRequestId: networkRequestId,
+          info: info
+        });
+      };
+
+      return network.execute(params, variables, cacheConfig, uploadables, logRequestInfo)["do"](logObserver);
+    }
+  };
+}
+
+module.exports = wrapNetworkWithLogObserver;

package/lib/query/GraphQLTag.js

@@ -12,9 +12,10 @@
 
 var RelayConcreteNode = require('../util/RelayConcreteNode');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
+
+var warning = require("fbjs/lib/warning"); // The type of a graphql`...` tagged template expression.
 
-var warning = require("fbjs/lib/warning");
 
 /**
  * Runtime function to correspond to the `graphql` tagged template function.