relay-runtime 11.0.0 → 13.0.0-rc.0

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,13 +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,
@@ -33,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") {
@@ -79,6 +82,7 @@ if (process.env.NODE_ENV !== "production") {
         validateSelections(optimisticResponse, selection.selections, context);
         return;
 
+      case CLIENT_COMPONENT:
       case FRAGMENT_SPREAD:
         validateSelections(optimisticResponse, selection.fragment.selections, context);
         return;
@@ -88,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,11 +53,28 @@ var RelayQueryResponseCache = /*#__PURE__*/function () {
 
     var response = this._responses.get(cacheKey);
 
-    return response != null ? (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.

package/lib/query/fetchQuery.js

@@ -17,18 +17,17 @@ var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/obje
 
 var RelayObservable = require('../network/RelayObservable');
 
-var fetchQueryInternal = require('./fetchQueryInternal');
-
-var invariant = require("fbjs/lib/invariant");
+var _require = require('../store/RelayModernOperationDescriptor'),
+    createOperationDescriptor = _require.createOperationDescriptor;
 
 var reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
 
-var _require = require('../store/RelayModernOperationDescriptor'),
-    createOperationDescriptor = _require.createOperationDescriptor;
+var fetchQueryInternal = require('./fetchQueryInternal');
 
 var _require2 = require('./GraphQLTag'),
     getRequest = _require2.getRequest;
 
+var invariant = require('invariant');
 /**
  * Fetches the given query and variables on the provided environment,
  * and de-dupes identical in-flight requests.
@@ -106,6 +105,8 @@ var _require2 = require('./GraphQLTag'),
  * ```
  * NOTE: When using .toPromise(), the request cannot be cancelled.
  */
+
+
 function fetchQuery(environment, query, variables, options) {
   var _options$fetchPolicy;
 

package/lib/query/fetchQueryInternal.js

@@ -14,7 +14,7 @@ var Observable = require('../network/RelayObservable');
 
 var RelayReplaySubject = require('../util/RelayReplaySubject');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
 var requestCachesByEnvironment = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();

package/lib/query/fetchQuery_DEPRECATED.js

@@ -15,12 +15,13 @@ var _require = require('../store/RelayModernOperationDescriptor'),
 
 var _require2 = require('./GraphQLTag'),
     getRequest = _require2.getRequest;
-
 /**
  * A helper function to fetch the results of a query. Note that results for
  * fragment spreads are masked: fields must be explicitly listed in the query in
  * order to be accessible in the result object.
  */
+
+
 function fetchQuery_DEPRECATED(environment, taggedNode, variables, cacheConfig) {
   var query = getRequest(taggedNode);
 

package/lib/store/ClientID.js

@@ -10,10 +10,16 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+
+var _require = require('../util/StringInterner'),
+    intern = _require.intern;
+
 var PREFIX = 'client:';
 
 function generateClientID(id, storageKey, index) {
-  var key = id + ':' + storageKey;
+  var internedId = RelayFeatureFlags.STRING_INTERN_LEVEL <= 0 ? id : intern(id, RelayFeatureFlags.MAX_DATA_ID_LENGTH);
+  var key = internedId + ':' + storageKey;
 
   if (index != null) {
     key += ':' + index;