relay-runtime 0.0.0-main-6cd701c5 → 0.0.0-main-e7cacf79

package/experimental.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-6cd701c5
+ * Relay v0.0.0-main-e7cacf79
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-6cd701c5
+ * Relay v0.0.0-main-e7cacf79
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/lib/multi-actor-environment/MultiActorEnvironment.js

@@ -14,7 +14,7 @@ var RelayRecordSource = require('../store/RelayRecordSource');
 var ActorSpecificEnvironment = require('./ActorSpecificEnvironment');
 var MultiActorEnvironment = /*#__PURE__*/function () {
   function MultiActorEnvironment(config) {
-    var _config$getDataID, _config$logFn, _config$relayFieldLog, _config$treatMissingF, _config$isServer, _config$missingFieldH, _config$defaultRender, _config$normalizeResp;
+    var _config$getDataID, _config$logFn, _config$relayFieldLog, _config$treatMissingF, _config$deferDeduplic, _config$isServer, _config$missingFieldH, _config$defaultRender, _config$normalizeResp;
     this._actorEnvironments = new Map();
     this._operationLoader = config.operationLoader;
     this._createNetworkForActor = config.createNetworkForActor;
@@ -26,6 +26,7 @@ var MultiActorEnvironment = /*#__PURE__*/function () {
     this._relayFieldLogger = (_config$relayFieldLog = config.relayFieldLogger) !== null && _config$relayFieldLog !== void 0 ? _config$relayFieldLog : defaultRelayFieldLogger;
     this._shouldProcessClientComponents = config.shouldProcessClientComponents;
     this._treatMissingFieldsAsNull = (_config$treatMissingF = config.treatMissingFieldsAsNull) !== null && _config$treatMissingF !== void 0 ? _config$treatMissingF : false;
+    this._deferDeduplicatedFields = (_config$deferDeduplic = config.deferDeduplicatedFields) !== null && _config$deferDeduplic !== void 0 ? _config$deferDeduplic : false;
     this._isServer = (_config$isServer = config.isServer) !== null && _config$isServer !== void 0 ? _config$isServer : false;
     this._missingFieldHandlers = (_config$missingFieldH = config.missingFieldHandlers) !== null && _config$missingFieldH !== void 0 ? _config$missingFieldH : [];
     this._createStoreForActor = config.createStoreForActor;
@@ -288,6 +289,7 @@ var MultiActorEnvironment = /*#__PURE__*/function () {
           return _this4.forActor(actorIdentifier).getStore();
         },
         treatMissingFieldsAsNull: _this4._treatMissingFieldsAsNull,
+        deferDeduplicatedFields: _this4._deferDeduplicatedFields,
         updater: updater,
         log: _this4._logFn,
         normalizeResponse: _this4._normalizeResponse

package/lib/store/OperationExecutor.js

@@ -49,12 +49,14 @@ var Executor = /*#__PURE__*/function () {
       sink = _ref3.sink,
       source = _ref3.source,
       treatMissingFieldsAsNull = _ref3.treatMissingFieldsAsNull,
+      deferDeduplicatedFields = _ref3.deferDeduplicatedFields,
       updater = _ref3.updater,
       log = _ref3.log,
       normalizeResponse = _ref3.normalizeResponse;
     this._actorIdentifier = actorIdentifier;
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
+    this._deferDeduplicatedFields = deferDeduplicatedFields;
     this._incrementalPayloadsPending = false;
     this._incrementalResults = new Map();
     this._log = log;
@@ -435,6 +437,7 @@ var Executor = /*#__PURE__*/function () {
     if (response) {
       var payload = this._normalizeResponse(response, this._operation.root, ROOT_TYPE, {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: this._getDataID,
         log: this._log,
         path: [],
@@ -521,6 +524,7 @@ var Executor = /*#__PURE__*/function () {
     };
     return this._normalizeResponse(nextResponse, selector, followupPayload.typeName, {
       actorIdentifier: this._actorIdentifier,
+      deferDeduplicatedFields: false,
       getDataID: this._getDataID,
       log: this._log,
       path: followupPayload.path,
@@ -578,6 +582,7 @@ var Executor = /*#__PURE__*/function () {
     return responses.map(function (payloadPart) {
       var relayPayload = _this8._normalizeResponse(payloadPart, _this8._operation.root, ROOT_TYPE, {
         actorIdentifier: _this8._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: _this8._getDataID,
         log: _this8._log,
         path: [],
@@ -868,6 +873,7 @@ var Executor = /*#__PURE__*/function () {
     this._actorIdentifier = (_placeholder$actorIde = placeholder.actorIdentifier) !== null && _placeholder$actorIde !== void 0 ? _placeholder$actorIde : this._actorIdentifier;
     var relayPayload = this._normalizeResponse(response, placeholder.selector, placeholder.typeName, {
       actorIdentifier: this._actorIdentifier,
+      deferDeduplicatedFields: this._deferDeduplicatedFields,
       getDataID: this._getDataID,
       log: this._log,
       path: placeholder.path,
@@ -971,6 +977,7 @@ var Executor = /*#__PURE__*/function () {
     });
     var relayPayload = this._normalizeResponse(response, selector, typeName, {
       actorIdentifier: this._actorIdentifier,
+      deferDeduplicatedFields: false,
       getDataID: this._getDataID,
       log: this._log,
       path: [].concat((0, _toConsumableArray2["default"])(normalizationPath), [responseKey, String(itemIndex)]),

package/lib/store/RelayModernEnvironment.js

@@ -24,6 +24,7 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
     var _config$store, _config$log, _config$relayFieldLog, _config$UNSTABLE_defa, _config$getDataID, _config$missingFieldH, _config$handlerProvid, _config$scheduler, _config$isServer, _config$normalizeResp, _config$operationTrac;
     this.configName = config.configName;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;
+    this._deferDeduplicatedFields = config.deferDeduplicatedFields === true;
     var operationLoader = config.operationLoader;
     if (process.env.NODE_ENV !== "production") {
       if (operationLoader != null) {
@@ -308,6 +309,7 @@ var RelayModernEnvironment = /*#__PURE__*/function () {
         sink: sink,
         source: createSource(),
         treatMissingFieldsAsNull: _this0._treatMissingFieldsAsNull,
+        deferDeduplicatedFields: _this0._deferDeduplicatedFields,
         updater: updater
       });
       return function () {

package/lib/store/RelayModernStore.js

@@ -29,7 +29,7 @@ var DEFAULT_RELEASE_BUFFER_SIZE = 10;
 var RelayModernStore = /*#__PURE__*/function () {
   function RelayModernStore(source, options) {
     var _this = this;
-    var _options$gcReleaseBuf, _options$shouldRetain, _options$gcScheduler, _options$getDataID, _options$log, _options$operationLoa, _options$shouldProces, _options$treatMissing;
+    var _options$gcReleaseBuf, _options$shouldRetain, _options$gcScheduler, _options$getDataID, _options$log, _options$operationLoa, _options$shouldProces, _options$treatMissing, _options$deferDedupli;
     (0, _defineProperty2["default"])(this, "_gcStep", function () {
       if (_this._gcRun) {
         if (_this._gcRun.next().done) {
@@ -74,6 +74,7 @@ var RelayModernStore = /*#__PURE__*/function () {
     this._updatedRecordIDs = new Set();
     this._shouldProcessClientComponents = (_options$shouldProces = options === null || options === void 0 ? void 0 : options.shouldProcessClientComponents) !== null && _options$shouldProces !== void 0 ? _options$shouldProces : false;
     this._treatMissingFieldsAsNull = (_options$treatMissing = options === null || options === void 0 ? void 0 : options.treatMissingFieldsAsNull) !== null && _options$treatMissing !== void 0 ? _options$treatMissing : false;
+    this._deferDeduplicatedFields = (_options$deferDedupli = options === null || options === void 0 ? void 0 : options.deferDeduplicatedFields) !== null && _options$deferDedupli !== void 0 ? _options$deferDedupli : false;
     this._actorIdentifier = options === null || options === void 0 ? void 0 : options.actorIdentifier;
     initializeRecordSource(this._recordSource);
   }
@@ -216,7 +217,7 @@ var RelayModernStore = /*#__PURE__*/function () {
       });
     }
     var source = this.getSource();
-    var snapshot = RelayReader.read(source, selector, this._resolverCache, this._resolverContext);
+    var snapshot = RelayReader.read(source, selector, log, this._resolverCache, this._resolverContext);
     if (process.env.NODE_ENV !== "production") {
       deepFreeze(snapshot);
     }
@@ -537,6 +538,7 @@ var RelayModernStore = /*#__PURE__*/function () {
       getDataID: this._getDataID,
       log: this.__log,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+      deferDeduplicatedFields: this._deferDeduplicatedFields,
       shouldProcessClientComponents: this._shouldProcessClientComponents,
       actorIdentifier: this._actorIdentifier
     };

package/lib/store/RelayPublishQueue.js

@@ -203,7 +203,7 @@ var RelayPublishQueue = /*#__PURE__*/function () {
   return RelayPublishQueue;
 }();
 function lookupSelector(source, selector) {
-  var selectorData = RelayReader.read(source, selector).data;
+  var selectorData = RelayReader.read(source, selector, null, undefined, undefined).data;
   if (process.env.NODE_ENV !== "production") {
     var deepFreeze = require('../util/deepFreeze');
     if (selectorData) {

package/lib/store/RelayReader.js

@@ -30,12 +30,12 @@ var _require4 = require('./ResolverFragments'),
 var _require5 = require('./TypeID'),
   generateTypeID = _require5.generateTypeID;
 var invariant = require('invariant');
-function read(recordSource, selector, resolverCache, resolverContext) {
-  var reader = new RelayReader(recordSource, selector, resolverCache !== null && resolverCache !== void 0 ? resolverCache : new NoopResolverCache(), resolverContext);
+function read(recordSource, selector, log, resolverCache, resolverContext) {
+  var reader = new RelayReader(recordSource, selector, log, resolverCache !== null && resolverCache !== void 0 ? resolverCache : new NoopResolverCache(), resolverContext);
   return reader.read();
 }
 var RelayReader = /*#__PURE__*/function () {
-  function RelayReader(recordSource, selector, resolverCache, resolverContext) {
+  function RelayReader(recordSource, selector, log, resolverCache, resolverContext) {
     var _selector$clientEdgeT, _ref, _this$_owner$node$ope, _this$_owner$node$ope2;
     this._clientEdgeTraversalPath = (_selector$clientEdgeT = selector.clientEdgeTraversalPath) !== null && _selector$clientEdgeT !== void 0 && _selector$clientEdgeT.length ? (0, _toConsumableArray2["default"])(selector.clientEdgeTraversalPath) : [];
     this._missingClientEdges = [];
@@ -53,6 +53,7 @@ var RelayReader = /*#__PURE__*/function () {
     this._fragmentName = selector.node.name;
     this._updatedDataIDs = new Set();
     this._resolverContext = resolverContext;
+    this._log = log;
   }
   var _proto = RelayReader.prototype;
   _proto.read = function read() {
@@ -85,6 +86,13 @@ var RelayReader = /*#__PURE__*/function () {
       this._resolverCache.notifyUpdatedSubscribers(this._updatedDataIDs);
       this._updatedDataIDs.clear();
     }
+    if (RelayFeatureFlags.ENABLE_READER_FRAGMENTS_LOGGING) {
+      var _this$_log;
+      (_this$_log = this._log) === null || _this$_log === void 0 ? void 0 : _this$_log.call(this, {
+        name: 'reader.read',
+        selector: this._selector
+      });
+    }
     return {
       data: data,
       fieldErrors: this._fieldErrors,
@@ -456,7 +464,7 @@ var RelayReader = /*#__PURE__*/function () {
           isMissingData: snapshot.isMissingData
         };
       }
-      snapshot = read(_this._recordSource, singularReaderSelector, _this._resolverCache);
+      snapshot = read(_this._recordSource, singularReaderSelector, null, _this._resolverCache, undefined);
       return {
         data: snapshot.data,
         fieldErrors: snapshot.fieldErrors,
@@ -860,11 +868,20 @@ var RelayReader = /*#__PURE__*/function () {
     if (data[ID_KEY] == null) {
       data[ID_KEY] = RelayModernRecord.getDataID(record);
     }
-    fragmentPointers[fragmentSpread.name] = getArgumentValues(fragmentSpread.args, this._variables, this._isWithinUnmatchedTypeRefinement);
+    var args = getArgumentValues(fragmentSpread.args, this._variables, this._isWithinUnmatchedTypeRefinement);
+    fragmentPointers[fragmentSpread.name] = args;
     data[FRAGMENT_OWNER_KEY] = this._owner;
     if (this._clientEdgeTraversalPath.length > 0 && this._clientEdgeTraversalPath[this._clientEdgeTraversalPath.length - 1] !== null) {
       data[CLIENT_EDGE_TRAVERSAL_PATH] = (0, _toConsumableArray2["default"])(this._clientEdgeTraversalPath);
     }
+    if (RelayFeatureFlags.ENABLE_READER_FRAGMENTS_LOGGING) {
+      var _this$_log2;
+      (_this$_log2 = this._log) === null || _this$_log2 === void 0 ? void 0 : _this$_log2.call(this, {
+        name: 'reader.fragmentSpread',
+        fragmentName: fragmentSpread.name,
+        data: data
+      });
+    }
   };
   _proto._createInlineDataOrResolverFragmentPointer = function _createInlineDataOrResolverFragmentPointer(fragmentSpreadOrFragment, record, data) {
     var fragmentPointers = data[FRAGMENTS_KEY];

package/lib/store/RelayResponseNormalizer.js

@@ -47,6 +47,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     this._getDataId = options.getDataID;
     this._handleFieldPayloads = [];
     this._treatMissingFieldsAsNull = options.treatMissingFieldsAsNull;
+    this._deferDeduplicatedFields = options.deferDeduplicatedFields;
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
     this._isUnmatchedAbstractType = false;
@@ -300,7 +301,7 @@ var RelayResponseNormalizer = /*#__PURE__*/function () {
     var isNoncompliantlyNullish = RelayFeatureFlags.ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS && Array.isArray(fieldValue) && fieldValue.length === 0;
     if (fieldValue == null || isNoncompliantlyNullish) {
       if (fieldValue === undefined) {
-        var isOptionalField = this._isClientExtension || this._isUnmatchedAbstractType;
+        var isOptionalField = this._isClientExtension || this._isUnmatchedAbstractType || this._deferDeduplicatedFields;
         if (isOptionalField) {
           return;
         } else if (!this._treatMissingFieldsAsNull) {

package/lib/store/RelayStoreSubscriptions.js

@@ -42,7 +42,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
         return;
       }
       var snapshot = subscription.snapshot;
-      var backup = RelayReader.read(source, snapshot.selector, _this2._resolverCache, _this2._resolverContext);
+      var backup = RelayReader.read(source, snapshot.selector, _this2.__log, _this2._resolverCache, _this2._resolverContext);
       var nextData = recycleNodesInto(snapshot.data, backup.data);
       backup.data = nextData;
       subscription.backup = backup;
@@ -106,7 +106,7 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
     if (!stale && !hasOverlappingUpdates) {
       return;
     }
-    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector, this._resolverCache, this._resolverContext) : backup;
+    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector, this.__log, this._resolverCache, this._resolverContext) : backup;
     var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
     nextSnapshot = {
       data: nextData,

package/lib/util/RelayError.js

@@ -1,6 +1,7 @@
 'use strict';
 
 function createError(type, name, messageFormat) {
+  var _messageParams$;
   for (var _len = arguments.length, messageParams = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
     messageParams[_key - 3] = arguments[_key];
   }
@@ -9,11 +10,13 @@ function createError(type, name, messageFormat) {
     return String(messageParams[index++]);
   });
   var err = new Error(message);
+  var operation = (_messageParams$ = messageParams[2]) !== null && _messageParams$ !== void 0 ? _messageParams$ : null;
   var error = Object.assign(err, {
     name: name,
     messageFormat: messageFormat,
     messageParams: messageParams,
     type: type,
+    operation: operation,
     taalOpcodes: [2, 2]
   });
   if (error.stack === undefined) {

package/lib/util/RelayFeatureFlags.js

@@ -28,6 +28,7 @@ var RelayFeatureFlags = {
   ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false,
   CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false,
   FILTER_OUT_RELAY_RESOLVER_RECORDS: false,
-  OPTIMIZE_NOTIFY: false
+  OPTIMIZE_NOTIFY: false,
+  ENABLE_READER_FRAGMENTS_LOGGING: false
 };
 module.exports = RelayFeatureFlags;

package/multi-actor-environment/MultiActorEnvironment.js.flow

@@ -71,6 +71,7 @@ export type MultiActorEnvironmentConfig = $ReadOnly<{
   scheduler?: ?TaskScheduler,
   shouldProcessClientComponents?: ?boolean,
   treatMissingFieldsAsNull?: boolean,
+  deferDeduplicatedFields?: boolean,
 }>;
 
 class MultiActorEnvironment implements IMultiActorEnvironment {
@@ -91,6 +92,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
   +_scheduler: ?TaskScheduler;
   +_shouldProcessClientComponents: ?boolean;
   +_treatMissingFieldsAsNull: boolean;
+  +_deferDeduplicatedFields: boolean;
 
   constructor(config: MultiActorEnvironmentConfig) {
     this._actorEnvironments = new Map();
@@ -106,6 +108,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     this._relayFieldLogger = config.relayFieldLogger ?? defaultRelayFieldLogger;
     this._shouldProcessClientComponents = config.shouldProcessClientComponents;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull ?? false;
+    this._deferDeduplicatedFields = config.deferDeduplicatedFields ?? false;
     this._isServer = config.isServer ?? false;
     this._missingFieldHandlers = config.missingFieldHandlers ?? [];
     this._createStoreForActor = config.createStoreForActor;
@@ -471,6 +474,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
           return this.forActor(actorIdentifier).getStore();
         },
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        deferDeduplicatedFields: this._deferDeduplicatedFields,
         updater,
         log: this._logFn,
         normalizeResponse: this._normalizeResponse,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "0.0.0-main-6cd701c5",
+  "version": "0.0.0-main-e7cacf79",
   "keywords": [
     "graphql",
     "relay"

package/store/OperationExecutor.js.flow

@@ -88,6 +88,7 @@ export type ExecuteConfig<TMutation: MutationParameters> = {
   +sink: Sink<GraphQLResponse>,
   +source: RelayObservable<GraphQLResponse>,
   +treatMissingFieldsAsNull: boolean,
+  +deferDeduplicatedFields: boolean,
   +updater?: ?SelectorStoreUpdater<TMutation['response']>,
   +log: LogFunction,
 };
@@ -127,6 +128,7 @@ class Executor<TMutation: MutationParameters> {
   _actorIdentifier: ActorIdentifier;
   _getDataID: GetDataID;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
   _incrementalPayloadsPending: boolean;
   _incrementalResults: Map<Label, Map<PathKey, IncrementalResults>>;
   _log: LogFunction;
@@ -178,6 +180,7 @@ class Executor<TMutation: MutationParameters> {
     sink,
     source,
     treatMissingFieldsAsNull,
+    deferDeduplicatedFields,
     updater,
     log,
     normalizeResponse,
@@ -185,6 +188,7 @@ class Executor<TMutation: MutationParameters> {
     this._actorIdentifier = actorIdentifier;
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
+    this._deferDeduplicatedFields = deferDeduplicatedFields;
     this._incrementalPayloadsPending = false;
     this._incrementalResults = new Map();
     this._log = log;
@@ -695,6 +699,7 @@ class Executor<TMutation: MutationParameters> {
         ROOT_TYPE,
         {
           actorIdentifier: this._actorIdentifier,
+          deferDeduplicatedFields: false,
           getDataID: this._getDataID,
           log: this._log,
           path: [],
@@ -813,6 +818,7 @@ class Executor<TMutation: MutationParameters> {
       followupPayload.typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: this._getDataID,
         log: this._log,
         path: followupPayload.path,
@@ -897,6 +903,7 @@ class Executor<TMutation: MutationParameters> {
         ROOT_TYPE,
         {
           actorIdentifier: this._actorIdentifier,
+          deferDeduplicatedFields: false,
           getDataID: this._getDataID,
           log: this._log,
           path: [],
@@ -1363,6 +1370,7 @@ class Executor<TMutation: MutationParameters> {
       placeholder.typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: this._deferDeduplicatedFields,
         getDataID: this._getDataID,
         log: this._log,
         path: placeholder.path,
@@ -1596,6 +1604,7 @@ class Executor<TMutation: MutationParameters> {
       typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: this._getDataID,
         log: this._log,
         path: [...normalizationPath, responseKey, String(itemIndex)],

package/store/RelayModernEnvironment.js.flow

@@ -67,6 +67,7 @@ export type EnvironmentConfig = {
   +configName?: string,
   +handlerProvider?: ?HandlerProvider,
   +treatMissingFieldsAsNull?: boolean,
+  +deferDeduplicatedFields?: boolean,
   +log?: ?LogFunction,
   +operationLoader?: ?OperationLoader,
   +network: INetwork,
@@ -97,6 +98,7 @@ class RelayModernEnvironment implements IEnvironment {
   _operationTracker: OperationTracker;
   _getDataID: GetDataID;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
   _operationExecutions: Map<string, ActiveState>;
   +options: mixed;
   +_isServer: boolean;
@@ -106,6 +108,7 @@ class RelayModernEnvironment implements IEnvironment {
   constructor(config: EnvironmentConfig) {
     this.configName = config.configName;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;
+    this._deferDeduplicatedFields = config.deferDeduplicatedFields === true;
     const operationLoader = config.operationLoader;
     if (__DEV__) {
       if (operationLoader != null) {
@@ -501,6 +504,7 @@ class RelayModernEnvironment implements IEnvironment {
         //       when the Observable is executed.
         source: createSource(),
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        deferDeduplicatedFields: this._deferDeduplicatedFields,
         updater,
       });
       return () => executor.cancel();

package/store/RelayModernStore.js.flow

@@ -116,6 +116,7 @@ class RelayModernStore implements Store {
   _resolverContext: ?ResolverContext;
   _actorIdentifier: ?ActorIdentifier;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
 
   constructor(
     source: MutableRecordSource,
@@ -135,6 +136,7 @@ class RelayModernStore implements Store {
       // These additional config options are only used if the experimental
       // @outputType resolver feature is used
       treatMissingFieldsAsNull?: ?boolean,
+      deferDeduplicatedFields?: ?boolean,
       actorIdentifier?: ?ActorIdentifier,
     },
   ) {
@@ -183,6 +185,7 @@ class RelayModernStore implements Store {
       options?.shouldProcessClientComponents ?? false;
 
     this._treatMissingFieldsAsNull = options?.treatMissingFieldsAsNull ?? false;
+    this._deferDeduplicatedFields = options?.deferDeduplicatedFields ?? false;
     this._actorIdentifier = options?.actorIdentifier;
 
     initializeRecordSource(this._recordSource);
@@ -402,6 +405,7 @@ class RelayModernStore implements Store {
     const snapshot = RelayReader.read(
       source,
       selector,
+      log,
       this._resolverCache,
       this._resolverContext,
     );
@@ -883,6 +887,7 @@ class RelayModernStore implements Store {
       getDataID: this._getDataID,
       log: this.__log,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+      deferDeduplicatedFields: this._deferDeduplicatedFields,
       shouldProcessClientComponents: this._shouldProcessClientComponents,
       actorIdentifier: this._actorIdentifier,
     };

package/store/RelayPublishQueue.js.flow

@@ -464,7 +464,16 @@ function lookupSelector(
   source: RecordSource,
   selector: SingularReaderSelector,
 ): ?SelectorData {
-  const selectorData = RelayReader.read(source, selector).data;
+  const selectorData = RelayReader.read(
+    source,
+    selector,
+    // The reader here is used to read the selector data for the updater.
+    // It is normal to not use all data in the update, so we don't pass
+    // the logger to skip tracking usages.
+    null,
+    undefined,
+    undefined,
+  ).data;
   if (__DEV__) {
     const deepFreeze = require('../util/deepFreeze');
     if (selectorData) {

package/store/RelayReader.js.flow

@@ -37,6 +37,7 @@ import type {
   DataIDSet,
   FieldError,
   FieldErrors,
+  LogFunction,
   MissingClientEdgeRequestInfo,
   Record,
   RecordSource,
@@ -78,12 +79,14 @@ const invariant = require('invariant');
 function read(
   recordSource: RecordSource,
   selector: SingularReaderSelector,
+  log: ?LogFunction,
   resolverCache?: ResolverCache,
   resolverContext?: ResolverContext,
 ): Snapshot {
   const reader = new RelayReader(
     recordSource,
     selector,
+    log,
     resolverCache ?? new NoopResolverCache(),
     resolverContext,
   );
@@ -115,10 +118,15 @@ class RelayReader {
   _resolverCache: ResolverCache;
   _fragmentName: string;
   _resolverContext: ?ResolverContext;
+  // The log function currently is only used to log fragment spread accesses for unused
+  // fragments detection, so it is not passed in from all callsites. If we decide to
+  // extend the logging, this needs to be updated.
+  _log: ?LogFunction;
 
   constructor(
     recordSource: RecordSource,
     selector: SingularReaderSelector,
+    log: ?LogFunction,
     resolverCache: ResolverCache,
     resolverContext: ?ResolverContext,
   ) {
@@ -144,6 +152,7 @@ class RelayReader {
     this._fragmentName = selector.node.name;
     this._updatedDataIDs = new Set();
     this._resolverContext = resolverContext;
+    this._log = log;
   }
 
   read(): Snapshot {
@@ -200,6 +209,14 @@ class RelayReader {
       this._resolverCache.notifyUpdatedSubscribers(this._updatedDataIDs);
       this._updatedDataIDs.clear();
     }
+
+    if (RelayFeatureFlags.ENABLE_READER_FRAGMENTS_LOGGING) {
+      this._log?.({
+        name: 'reader.read',
+        selector: this._selector,
+      });
+    }
+
     return {
       data,
       fieldErrors: this._fieldErrors,
@@ -770,7 +787,12 @@ class RelayReader {
       snapshot = read(
         this._recordSource,
         singularReaderSelector,
+        // This reads data for a rootFragment in read time resolvers. There is no fragment
+        // spread created for it so the existing fragment spread logger can't be used to log
+        // unused rootFragments. Thus we skip passing the logger here for now.
+        null,
         this._resolverCache,
+        undefined,
       );
 
       return {
@@ -1583,12 +1605,13 @@ class RelayReader {
     if (data[ID_KEY] == null) {
       data[ID_KEY] = RelayModernRecord.getDataID(record);
     }
-    // $FlowFixMe[cannot-write] - writing into read-only field
-    fragmentPointers[fragmentSpread.name] = getArgumentValues(
+    const args = getArgumentValues(
       fragmentSpread.args,
       this._variables,
       this._isWithinUnmatchedTypeRefinement,
     );
+    // $FlowFixMe[cannot-write] - writing into read-only field
+    fragmentPointers[fragmentSpread.name] = args;
     data[FRAGMENT_OWNER_KEY] = this._owner;
 
     if (
@@ -1599,6 +1622,14 @@ class RelayReader {
     ) {
       data[CLIENT_EDGE_TRAVERSAL_PATH] = [...this._clientEdgeTraversalPath];
     }
+
+    if (RelayFeatureFlags.ENABLE_READER_FRAGMENTS_LOGGING) {
+      this._log?.({
+        name: 'reader.fragmentSpread',
+        fragmentName: fragmentSpread.name,
+        data,
+      });
+    }
   }
 
   _createInlineDataOrResolverFragmentPointer(

package/store/RelayResponseNormalizer.js.flow

@@ -76,6 +76,7 @@ export type GetDataID = (
 export type NormalizationOptions = {
   +getDataID: GetDataID,
   +treatMissingFieldsAsNull: boolean,
+  +deferDeduplicatedFields: boolean,
   +log: ?LogFunction,
   +path?: $ReadOnlyArray<string>,
   +shouldProcessClientComponents?: ?boolean,
@@ -114,6 +115,7 @@ class RelayResponseNormalizer {
   _getDataId: GetDataID;
   _handleFieldPayloads: Array<HandleFieldPayload>;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
   _incrementalPlaceholders: Array<IncrementalDataPlaceholder>;
   _isClientExtension: boolean;
   _isUnmatchedAbstractType: boolean;
@@ -136,6 +138,7 @@ class RelayResponseNormalizer {
     this._getDataId = options.getDataID;
     this._handleFieldPayloads = [];
     this._treatMissingFieldsAsNull = options.treatMissingFieldsAsNull;
+    this._deferDeduplicatedFields = options.deferDeduplicatedFields;
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
     this._isUnmatchedAbstractType = false;
@@ -525,7 +528,9 @@ class RelayResponseNormalizer {
         // client is assumed to be correctly configured with
         // treatMissingFieldsAsNull=true.
         const isOptionalField =
-          this._isClientExtension || this._isUnmatchedAbstractType;
+          this._isClientExtension ||
+          this._isUnmatchedAbstractType ||
+          this._deferDeduplicatedFields;
 
         if (isOptionalField) {
           // Field not expected to exist regardless of whether the server is pruning null

package/store/RelayStoreSubscriptions.js.flow

@@ -101,6 +101,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
       const backup = RelayReader.read(
         source,
         snapshot.selector,
+        this.__log,
         this._resolverCache,
         this._resolverContext,
       );
@@ -212,6 +213,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
         ? RelayReader.read(
             source,
             snapshot.selector,
+            this.__log,
             this._resolverCache,
             this._resolverContext,
           )

package/store/RelayStoreTypes.js.flow

@@ -777,6 +777,17 @@ export type StoreNotifySubscriptionLogEvent = {
   +nextSnapshot: Snapshot,
 };
 
+export type ReaderReadFragmentSpread = {
+  +name: 'reader.fragmentSpread',
+  fragmentName: string,
+  data: SelectorData,
+};
+
+export type ReaderRead = {
+  name: 'reader.read',
+  selector: SingularReaderSelector,
+};
+
 export type EntrypointRootConsumeLogEvent = {
   +name: 'entrypoint.root.consume',
   +profilerContext: mixed,
@@ -855,7 +866,9 @@ export type LogEvent =
   | LiveResolverBatchStartLogEvent
   | LiveResolverBatchEndLogEvent
   | UseFragmentSubscriptionMissedUpdates
-  | FetchQueryFetchLogEvent;
+  | FetchQueryFetchLogEvent
+  | ReaderRead
+  | ReaderReadFragmentSpread;
 
 export type LogFunction = LogEvent => void;
 export type LogRequestInfoFunction = mixed => void;

package/util/RelayError.js.flow

@@ -25,12 +25,15 @@ function createError(
     String(messageParams[index++]),
   );
   const err = new Error(message);
+  // messageParams[2] is the operation name
+  const operation = messageParams[2] ?? null;
   // $FlowFixMe[unsafe-object-assign]
   const error = Object.assign(err as any, {
     name,
     messageFormat,
     messageParams,
     type,
+    operation,
     taalOpcodes: [2, 2], // skip frame (code=2) twice
   });
   // In V8, Error objects keep the closure scope chain alive until the

package/util/RelayFeatureFlags.js.flow

@@ -87,6 +87,9 @@ export type FeatureFlags = {
 
   // Reduce the work on store.notify
   OPTIMIZE_NOTIFY: boolean,
+
+  // Enable logging for reader reading fragment spreads and fragments. Useful for logging unused fragments.
+  ENABLE_READER_FRAGMENTS_LOGGING: boolean,
 };
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -118,6 +121,7 @@ const RelayFeatureFlags: FeatureFlags = {
   CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false,
   FILTER_OUT_RELAY_RESOLVER_RECORDS: false,
   OPTIMIZE_NOTIFY: false,
+  ENABLE_READER_FRAGMENTS_LOGGING: false,
 };
 
 module.exports = RelayFeatureFlags;