relay-runtime 11.0.0 → 13.0.0-rc.0

package/lib/store/RelayStoreSubscriptions.js

@@ -10,20 +10,21 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+var deepFreeze = require('../util/deepFreeze');
 
-var RelayReader = require('./RelayReader');
+var recycleNodesInto = require('../util/recycleNodesInto');
 
-var deepFreeze = require('../util/deepFreeze');
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 var hasOverlappingIDs = require('./hasOverlappingIDs');
 
-var recycleNodesInto = require('../util/recycleNodesInto');
+var RelayReader = require('./RelayReader');
 
 var RelayStoreSubscriptions = /*#__PURE__*/function () {
-  function RelayStoreSubscriptions(log) {
+  function RelayStoreSubscriptions(log, resolverCache) {
     this._subscriptions = new Set();
     this.__log = log;
+    this._resolverCache = resolverCache;
   }
 
   var _proto = RelayStoreSubscriptions.prototype;
@@ -50,6 +51,8 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
   };
 
   _proto.snapshotSubscriptions = function snapshotSubscriptions(source) {
+    var _this2 = this;
+
     this._subscriptions.forEach(function (subscription) {
       // Backup occurs after writing a new "final" payload(s) and before (re)applying
       // optimistic changes. Each subscription's `snapshot` represents what was *last
@@ -69,7 +72,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
       }
 
       var snapshot = subscription.snapshot;
-      var backup = RelayReader.read(source, snapshot.selector);
+      var backup = RelayReader.read(source, snapshot.selector, _this2._resolverCache);
       var nextData = recycleNodesInto(snapshot.data, backup.data);
       backup.data = nextData; // backup owns the snapshot and can safely mutate
 
@@ -90,6 +93,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
         subscription.snapshot = {
           data: subscription.snapshot.data,
           isMissingData: backup.isMissingData,
+          missingClientEdges: backup.missingClientEdges,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
           missingRequiredFields: backup.missingRequiredFields
@@ -101,12 +105,12 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
   };
 
   _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners, sourceOperation) {
-    var _this2 = this;
+    var _this3 = this;
 
     var hasUpdatedRecords = updatedRecordIDs.size !== 0;
 
     this._subscriptions.forEach(function (subscription) {
-      var owner = _this2._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);
+      var owner = _this3._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);
 
       if (owner != null) {
         updatedOwners.push(owner);
@@ -134,11 +138,12 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
       return;
     }
 
-    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector) : backup;
+    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector, this._resolverCache) : backup;
     var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
     nextSnapshot = {
       data: nextData,
       isMissingData: nextSnapshot.isMissingData,
+      missingClientEdges: nextSnapshot.missingClientEdges,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
       missingRequiredFields: nextSnapshot.missingRequiredFields

package/lib/store/RelayStoreUtils.js

@@ -14,14 +14,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
-var RelayConcreteNode = require('../util/RelayConcreteNode');
-
 var getRelayHandleKey = require('../util/getRelayHandleKey');
 
-var invariant = require("fbjs/lib/invariant");
+var RelayConcreteNode = require('../util/RelayConcreteNode');
 
 var stableCopy = require('../util/stableCopy');
 
+var invariant = require('invariant');
+
 var VARIABLE = RelayConcreteNode.VARIABLE,
     LITERAL = RelayConcreteNode.LITERAL,
     OBJECT_VALUE = RelayConcreteNode.OBJECT_VALUE,
@@ -122,8 +122,8 @@ function getStorageKey(field, variables) {
     return field.storageKey;
   }
 
-  var args = field.args,
-      name = field.name;
+  var args = typeof field.args === 'undefined' ? undefined : field.args;
+  var name = field.name;
   return args && args.length !== 0 ? formatStorageKey(name, getArgumentValues(args, variables)) : name;
 }
 /**
@@ -192,6 +192,8 @@ function getModuleOperationKey(documentName) {
 
 
 var RelayStoreUtils = {
+  ACTOR_IDENTIFIER_KEY: '__actorIdentifier',
+  CLIENT_EDGE_TRAVERSAL_PATH: '__clientEdgeTraversalPath',
   FRAGMENTS_KEY: '__fragments',
   FRAGMENT_OWNER_KEY: '__fragmentOwner',
   FRAGMENT_PROP_NAME_KEY: '__fragmentPropName',
@@ -205,6 +207,10 @@ var RelayStoreUtils = {
   TYPENAME_KEY: '__typename',
   INVALIDATED_AT_KEY: '__invalidated_at',
   IS_WITHIN_UNMATCHED_TYPE_REFINEMENT: '__isWithinUnmatchedTypeRefinement',
+  RELAY_RESOLVER_VALUE_KEY: '__resolverValue',
+  RELAY_RESOLVER_INVALIDATION_KEY: '__resolverValueMayBeInvalid',
+  RELAY_RESOLVER_INPUTS_KEY: '__resolverInputValues',
+  RELAY_RESOLVER_READER_SELECTOR_KEY: '__resolverReaderSelector',
   formatStorageKey: formatStorageKey,
   getArgumentValue: getArgumentValue,
   getArgumentValues: getArgumentValues,

package/lib/store/ResolverCache.js

@@ -0,0 +1,213 @@
+/**
+ * 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 _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var recycleNodesInto = require('../util/recycleNodesInto');
+
+var _require = require('./ClientID'),
+    generateClientID = _require.generateClientID;
+
+var RelayModernRecord = require('./RelayModernRecord');
+
+var _require2 = require('./RelayStoreUtils'),
+    RELAY_RESOLVER_INPUTS_KEY = _require2.RELAY_RESOLVER_INPUTS_KEY,
+    RELAY_RESOLVER_INVALIDATION_KEY = _require2.RELAY_RESOLVER_INVALIDATION_KEY,
+    RELAY_RESOLVER_READER_SELECTOR_KEY = _require2.RELAY_RESOLVER_READER_SELECTOR_KEY,
+    RELAY_RESOLVER_VALUE_KEY = _require2.RELAY_RESOLVER_VALUE_KEY,
+    getStorageKey = _require2.getStorageKey;
+
+var warning = require("fbjs/lib/warning");
+
+// $FlowFixMe[unclear-type] - will always be empty
+var emptySet = new Set();
+
+var NoopResolverCache = /*#__PURE__*/function () {
+  function NoopResolverCache() {}
+
+  var _proto = NoopResolverCache.prototype;
+
+  _proto.readFromCacheOrEvaluate = function readFromCacheOrEvaluate(record, field, variables, evaluate, getDataForResolverFragment) {
+    return [evaluate().resolverResult, undefined];
+  };
+
+  _proto.invalidateDataIDs = function invalidateDataIDs(updatedDataIDs) {};
+
+  return NoopResolverCache;
+}();
+
+function addDependencyEdge(edges, from, to) {
+  var set = edges.get(from);
+
+  if (!set) {
+    set = new Set();
+    edges.set(from, set);
+  }
+
+  set.add(to);
+}
+
+var RecordResolverCache = /*#__PURE__*/function () {
+  function RecordResolverCache(getRecordSource) {
+    this._resolverIDToRecordIDs = new Map();
+    this._recordIDToResolverIDs = new Map();
+    this._getRecordSource = getRecordSource;
+  }
+
+  var _proto2 = RecordResolverCache.prototype;
+
+  _proto2.readFromCacheOrEvaluate = function readFromCacheOrEvaluate(record, field, variables, evaluate, getDataForResolverFragment) {
+    var recordSource = this._getRecordSource();
+
+    var recordID = RelayModernRecord.getDataID(record);
+    var storageKey = getStorageKey(field, variables);
+    var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
+    var linkedRecord = linkedID == null ? null : recordSource.get(linkedID);
+
+    if (linkedRecord == null || this._isInvalid(linkedRecord, getDataForResolverFragment)) {
+      var _linkedID;
+
+      // Cache miss; evaluate the selector and store the result in a new record:
+      linkedID = (_linkedID = linkedID) !== null && _linkedID !== void 0 ? _linkedID : generateClientID(recordID, storageKey);
+      linkedRecord = RelayModernRecord.create(linkedID, '__RELAY_RESOLVER__');
+      var evaluationResult = evaluate();
+      RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_VALUE_KEY, evaluationResult.resolverResult);
+      RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_INPUTS_KEY, evaluationResult.fragmentValue);
+      RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_READER_SELECTOR_KEY, evaluationResult.readerSelector);
+      recordSource.set(linkedID, linkedRecord); // Link the resolver value record to the resolver field of the record being read:
+
+      var nextRecord = RelayModernRecord.clone(record);
+      RelayModernRecord.setLinkedRecordID(nextRecord, storageKey, linkedID);
+      recordSource.set(RelayModernRecord.getDataID(nextRecord), nextRecord); // Put records observed by the resolver into the dependency graph:
+
+      var resolverID = evaluationResult.resolverID;
+      addDependencyEdge(this._resolverIDToRecordIDs, resolverID, linkedID);
+      addDependencyEdge(this._recordIDToResolverIDs, recordID, resolverID);
+
+      var _iterator = (0, _createForOfIteratorHelper2["default"])(evaluationResult.seenRecordIDs),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var seenRecordID = _step.value;
+          addDependencyEdge(this._recordIDToResolverIDs, seenRecordID, resolverID);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    } // $FlowFixMe[incompatible-type] - will always be empty
+
+
+    var answer = linkedRecord[RELAY_RESOLVER_VALUE_KEY];
+    return [answer, linkedID];
+  };
+
+  _proto2.invalidateDataIDs = function invalidateDataIDs(updatedDataIDs) {
+    var recordSource = this._getRecordSource();
+
+    var visited = new Set();
+    var recordsToVisit = Array.from(updatedDataIDs);
+
+    while (recordsToVisit.length) {
+      var recordID = recordsToVisit.pop();
+      updatedDataIDs.add(recordID);
+
+      var _iterator2 = (0, _createForOfIteratorHelper2["default"])((_this$_recordIDToReso = this._recordIDToResolverIDs.get(recordID)) !== null && _this$_recordIDToReso !== void 0 ? _this$_recordIDToReso : emptySet),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _this$_recordIDToReso;
+
+          var fragment = _step2.value;
+
+          if (!visited.has(fragment)) {
+            var _iterator3 = (0, _createForOfIteratorHelper2["default"])((_this$_resolverIDToRe = this._resolverIDToRecordIDs.get(fragment)) !== null && _this$_resolverIDToRe !== void 0 ? _this$_resolverIDToRe : emptySet),
+                _step3;
+
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _this$_resolverIDToRe;
+
+                var anotherRecordID = _step3.value;
+
+                this._markInvalidatedResolverRecord(anotherRecordID, recordSource, updatedDataIDs);
+
+                if (!visited.has(anotherRecordID)) {
+                  recordsToVisit.push(anotherRecordID);
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  };
+
+  _proto2._markInvalidatedResolverRecord = function _markInvalidatedResolverRecord(dataID, recordSource, // Written to
+  updatedDataIDs) // Mutated in place
+  {
+    var record = recordSource.get(dataID);
+
+    if (!record) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'Expected a resolver record with ID %s, but it was missing.', dataID) : void 0;
+      return;
+    }
+
+    var nextRecord = RelayModernRecord.clone(record);
+    RelayModernRecord.setValue(nextRecord, RELAY_RESOLVER_INVALIDATION_KEY, true);
+    recordSource.set(dataID, nextRecord);
+  };
+
+  _proto2._isInvalid = function _isInvalid(record, getDataForResolverFragment) {
+    if (!RelayModernRecord.getValue(record, RELAY_RESOLVER_INVALIDATION_KEY)) {
+      return false;
+    }
+
+    var originalInputs = RelayModernRecord.getValue(record, RELAY_RESOLVER_INPUTS_KEY); // $FlowFixMe[incompatible-type] - storing values in records is not typed
+
+    var readerSelector = RelayModernRecord.getValue(record, RELAY_RESOLVER_READER_SELECTOR_KEY);
+
+    if (originalInputs == null || readerSelector == null) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'Expected previous inputs and reader selector on resolver record with ID %s, but they were missing.', RelayModernRecord.getDataID(record)) : void 0;
+      return true;
+    }
+
+    var latestValues = getDataForResolverFragment(readerSelector);
+    var recycled = recycleNodesInto(originalInputs, latestValues);
+
+    if (recycled !== originalInputs) {
+      return true;
+    }
+
+    return false;
+  };
+
+  return RecordResolverCache;
+}();
+
+module.exports = {
+  NoopResolverCache: NoopResolverCache,
+  RecordResolverCache: RecordResolverCache
+};

package/lib/store/ResolverFragments.js

@@ -0,0 +1,61 @@
+/**
+ * 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 _require = require('../query/GraphQLTag'),
+    getFragment = _require.getFragment;
+
+var _require2 = require('./RelayModernSelector'),
+    getSelector = _require2.getSelector;
+
+var invariant = require('invariant'); // When we call the user-supplied resolver function, it will in turn call
+// `readFragment`, but that's a global function -- it needs information
+// about what resolver is being executed, which is supplied by putting the
+// info on this stack before we call the resolver function.
+
+
+var contextStack = [];
+
+function withResolverContext(context, cb) {
+  contextStack.push(context);
+
+  try {
+    return cb();
+  } finally {
+    contextStack.pop();
+  }
+} // NOTE: these declarations are copied from 'useFragment'; it would be good
+// to figure out how to share the same type signature between the two functions.
+// The declarations ensure that the type of the returned data is:
+//   - non-nullable if the provided ref type is non-nullable
+//   - nullable if the provided ref type is nullable
+//   - array of non-nullable if the privoided ref type is an array of
+//     non-nullable refs
+//   - array of nullable if the privoided ref type is an array of nullable refs
+
+
+function readFragment(fragmentInput, fragmentKey) {
+  if (!contextStack.length) {
+    throw new Error('readFragment should be called only from within a Relay Resolver function.');
+  }
+
+  var context = contextStack[contextStack.length - 1];
+  var fragmentNode = getFragment(fragmentInput);
+  var fragmentSelector = getSelector(fragmentNode, fragmentKey);
+  !(fragmentSelector != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Expected a selector for the fragment of the resolver ".concat(fragmentNode.name, ", but got null.")) : invariant(false) : void 0;
+  !(fragmentSelector.kind === 'SingularReaderSelector') ? process.env.NODE_ENV !== "production" ? invariant(false, "Expected a singular reader selector for the fragment of the resolver ".concat(fragmentNode.name, ", but it was plural.")) : invariant(false) : void 0;
+  return context.getDataForResolverFragment(fragmentSelector, fragmentKey);
+}
+
+module.exports = {
+  readFragment: readFragment,
+  withResolverContext: withResolverContext
+};

package/lib/store/cloneRelayHandleSourceField.js

@@ -10,16 +10,15 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var areEqual = require("fbjs/lib/areEqual");
-
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('../util/RelayConcreteNode'),
     LINKED_FIELD = _require.LINKED_FIELD;
 
 var _require2 = require('./RelayStoreUtils'),
     getHandleStorageKey = _require2.getHandleStorageKey;
 
+var areEqual = require("fbjs/lib/areEqual");
+
+var invariant = require('invariant');
 /**
  * @private
  *
@@ -27,6 +26,8 @@ var _require2 = require('./RelayStoreUtils'),
  * field (on which the handle was declared) among the sibling `selections`, and
  * copying its selections into the clone.
  */
+
+
 function cloneRelayHandleSourceField(handleField, selections, variables) {
   var sourceField = selections.find(function (source) {
     return source.kind === LINKED_FIELD && source.name === handleField.name && source.alias === handleField.alias && areEqual(source.args, handleField.args);

package/lib/store/cloneRelayScalarHandleSourceField.js

@@ -10,22 +10,23 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var areEqual = require("fbjs/lib/areEqual");
-
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('../util/RelayConcreteNode'),
     SCALAR_FIELD = _require.SCALAR_FIELD;
 
 var _require2 = require('./RelayStoreUtils'),
     getHandleStorageKey = _require2.getHandleStorageKey;
 
+var areEqual = require("fbjs/lib/areEqual");
+
+var invariant = require('invariant');
 /**
  * @private
  *
  * Creates a clone of the supplied `handleField` by finding the original scalar
  * field (on which the handle was declared) among the sibling `selections`.
  */
+
+
 function cloneRelayScalarHandleSourceField(handleField, selections, variables) {
   var sourceField = selections.find(function (source) {
     return source.kind === SCALAR_FIELD && source.name === handleField.name && source.alias === handleField.alias && areEqual(source.args, handleField.args);

package/lib/store/createRelayContext.js

@@ -10,7 +10,9 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant'); // Ideally, we'd just import the type of the react module, but this causes Flow
+// problems.
+
 
 var relayContext;
 var firstReact;
@@ -26,7 +28,7 @@ function createRelayContext(react) {
     firstReact = react;
   }
 
-  !(react === firstReact) ? process.env.NODE_ENV !== "production" ? invariant(false, '[createRelayContext]: You passing a different instance of React', react.version) : invariant(false) : void 0;
+  !(react === firstReact) ? process.env.NODE_ENV !== "production" ? invariant(false, '[createRelayContext]: You are passing a different instance of React', react.version) : invariant(false) : void 0;
   return relayContext;
 }
 

package/lib/store/defaultGetDataID.js

@@ -16,8 +16,10 @@ var _require = require('./ViewerPattern'),
 
 function defaultGetDataID(fieldValue, typeName) {
   if (typeName === VIEWER_TYPE) {
+    // $FlowFixMe[prop-missing]
     return fieldValue.id == null ? VIEWER_ID : fieldValue.id;
-  }
+  } // $FlowFixMe[prop-missing]
+
 
   return fieldValue.id;
 }

package/lib/store/readInlineData.js

@@ -10,14 +10,18 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
-
 var _require = require('../query/GraphQLTag'),
     getInlineDataFragment = _require.getInlineDataFragment;
 
 var _require2 = require('./RelayStoreUtils'),
     FRAGMENTS_KEY = _require2.FRAGMENTS_KEY;
 
+var invariant = require('invariant');
+/**
+ * Reads an @inline data fragment that was spread into the parent fragment.
+ */
+
+
 function readInlineData(fragment, fragmentRef) {
   var _fragmentRef$FRAGMENT;
 

package/lib/subscription/requestSubscription.js

@@ -12,14 +12,19 @@
 
 var RelayDeclarativeMutationConfig = require('../mutations/RelayDeclarativeMutationConfig');
 
-var warning = require("fbjs/lib/warning");
-
 var _require = require('../query/GraphQLTag'),
     getRequest = _require.getRequest;
 
 var _require2 = require('../store/RelayModernOperationDescriptor'),
     createOperationDescriptor = _require2.createOperationDescriptor;
 
+var _require3 = require('../store/RelayModernSelector'),
+    createReaderSelector = _require3.createReaderSelector;
+
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
+
+var warning = require("fbjs/lib/warning");
+
 function requestSubscription(environment, config) {
   var subscription = getRequest(config.subscription);
 
@@ -38,18 +43,39 @@ function requestSubscription(environment, config) {
 
   var _ref = configs ? RelayDeclarativeMutationConfig.convert(configs, subscription, null
   /* optimisticUpdater */
-  , config.updater) : config,
+  ,
+  /* optimisticUpdater */
+  config.updater) : config,
       updater = _ref.updater;
 
-  var sub = environment.execute({
+  var sub = environment.executeSubscription({
     operation: operation,
     updater: updater
-  }).map(function () {
-    var data = environment.lookup(operation.fragment).data; // $FlowFixMe[incompatible-cast]
-
-    return data;
   }).subscribe({
-    next: onNext,
+    next: function next(responses) {
+      if (onNext != null) {
+        var selector = operation.fragment;
+        var nextID;
+
+        if (Array.isArray(responses)) {
+          var _responses$, _responses$$extension;
+
+          nextID = (_responses$ = responses[0]) === null || _responses$ === void 0 ? void 0 : (_responses$$extension = _responses$.extensions) === null || _responses$$extension === void 0 ? void 0 : _responses$$extension.__relay_subscription_root_id;
+        } else {
+          var _responses$extensions;
+
+          nextID = (_responses$extensions = responses.extensions) === null || _responses$extensions === void 0 ? void 0 : _responses$extensions.__relay_subscription_root_id;
+        }
+
+        if (typeof nextID === 'string') {
+          selector = createReaderSelector(selector.node, nextID, selector.variables, selector.owner);
+        }
+
+        var data = environment.lookup(selector).data; // $FlowFixMe[incompatible-cast]
+
+        onNext(data);
+      }
+    },
     error: onError,
     complete: onCompleted
   });

package/lib/util/RelayConcreteNode.js

@@ -24,7 +24,10 @@
  * for local caching.
  */
 var RelayConcreteNode = {
+  ACTOR_CHANGE: 'ActorChange',
   CONDITION: 'Condition',
+  CLIENT_COMPONENT: 'ClientComponent',
+  CLIENT_EDGE: 'ClientEdge',
   CLIENT_EXTENSION: 'ClientExtension',
   DEFER: 'Defer',
   CONNECTION: 'Connection',
@@ -40,6 +43,7 @@ var RelayConcreteNode = {
   LIST_VALUE: 'ListValue',
   LOCAL_ARGUMENT: 'LocalArgument',
   MODULE_IMPORT: 'ModuleImport',
+  RELAY_RESOLVER: 'RelayResolver',
   REQUIRED_FIELD: 'RequiredField',
   OBJECT_VALUE: 'ObjectValue',
   OPERATION: 'Operation',

package/lib/util/RelayFeatureFlags.js

@@ -11,17 +11,24 @@
 'use strict';
 
 var RelayFeatureFlags = {
+  DELAY_CLEANUP_OF_PENDING_PRELOAD_QUERIES: false,
+  ENABLE_CLIENT_EDGES: false,
   ENABLE_VARIABLE_CONNECTION_KEY: false,
   ENABLE_PARTIAL_RENDERING_DEFAULT: true,
-  ENABLE_RELAY_CONTAINERS_SUSPENSE: true,
-  ENABLE_PRECISE_TYPE_REFINEMENT: false,
   ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,
   ENABLE_REQUIRED_DIRECTIVES: false,
+  ENABLE_RELAY_RESOLVERS: false,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
-  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: false,
   ENABLE_LOAD_QUERY_REQUEST_DEDUPING: true,
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: false,
-  ENABLE_NOTIFY_SUBSCRIPTION: false
+  ENABLE_NOTIFY_SUBSCRIPTION: false,
+  BATCH_ASYNC_MODULE_UPDATES_FN: null,
+  ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT: false,
+  ENABLE_QUERY_RENDERER_OFFSCREEN_SUPPORT: false,
+  MAX_DATA_ID_LENGTH: null,
+  REFACTOR_SUSPENSE_RESOURCE: true,
+  STRING_INTERN_LEVEL: 0,
+  USE_REACT_CACHE: false
 };
 module.exports = RelayFeatureFlags;