relay-runtime 18.1.0 → 19.0.0

package/lib/store/observeFragmentExperimental.js

@@ -1,14 +1,17 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator").default;
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 var Observable = require('../network/RelayObservable');
-var _require = require('../query/GraphQLTag'),
-  getFragment = _require.getFragment;
-var getPendingOperationsForFragment = require('../util/getPendingOperationsForFragment');
-var _require2 = require('../util/handlePotentialSnapshotErrors'),
-  handlePotentialSnapshotErrors = _require2.handlePotentialSnapshotErrors;
-var _require3 = require('./RelayModernSelector'),
-  getSelector = _require3.getSelector;
+var _require = require('../query/fetchQueryInternal'),
+  getObservableForActiveRequest = _require.getObservableForActiveRequest;
+var _require2 = require('../query/GraphQLTag'),
+  getFragment = _require2.getFragment;
+var _require3 = require('../util/handlePotentialSnapshotErrors'),
+  handlePotentialSnapshotErrors = _require3.handlePotentialSnapshotErrors;
+var _require4 = require('./RelayModernSelector'),
+  getSelector = _require4.getSelector;
 var invariant = require('invariant');
 function waitForFragmentData(_x, _x2, _x3) {
   return _waitForFragmentData.apply(this, arguments);
@@ -47,15 +50,15 @@ function observeFragment(environment, fragment, fragmentRef) {
   !(fragmentSelector != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected a selector, got null.') : invariant(false) : void 0;
   switch (fragmentSelector.kind) {
     case 'SingularReaderSelector':
-      return observeSelector(environment, fragment, fragmentSelector);
+      return observeSingularSelector(environment, fragment, fragmentSelector);
     case 'PluralReaderSelector':
       {
-        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Plural fragments are not supported') : invariant(false) : void 0;
+        return observePluralSelector(environment, fragment, fragmentSelector);
       }
   }
   !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Unsupported fragment selector kind') : invariant(false) : void 0;
 }
-function observeSelector(environment, fragmentNode, fragmentSelector) {
+function observeSingularSelector(environment, fragmentNode, fragmentSelector) {
   var snapshot = environment.lookup(fragmentSelector);
   return Observable.create(function (sink) {
     sink.next(snapshotToFragmentState(environment, fragmentNode, fragmentSelector.owner, snapshot));
@@ -67,6 +70,28 @@ function observeSelector(environment, fragmentNode, fragmentSelector) {
     };
   });
 }
+function observePluralSelector(environment, fragmentNode, fragmentSelector) {
+  var snapshots = fragmentSelector.selectors.map(function (selector) {
+    return environment.lookup(selector);
+  });
+  return Observable.create(function (sink) {
+    var states = snapshots.map(function (snapshot, index) {
+      return snapshotToFragmentState(environment, fragmentNode, fragmentSelector.selectors[index].owner, snapshot);
+    });
+    sink.next(mergeFragmentStates(states));
+    var subscriptions = snapshots.map(function (snapshot, index) {
+      return environment.subscribe(snapshot, function (latestSnapshot) {
+        states[index] = snapshotToFragmentState(environment, fragmentNode, fragmentSelector.selectors[index].owner, latestSnapshot);
+        sink.next(mergeFragmentStates(states));
+      });
+    });
+    return function () {
+      return subscriptions.forEach(function (subscription) {
+        return subscription.dispose();
+      });
+    };
+  });
+}
 function snapshotToFragmentState(environment, fragmentNode, owner, snapshot) {
   var missingLiveResolverFields = snapshot.missingLiveResolverFields != null && snapshot.missingLiveResolverFields.length > 0;
   var missingClientEdges = snapshot.missingClientEdges != null && snapshot.missingClientEdges.length > 0;
@@ -76,15 +101,14 @@ function snapshotToFragmentState(environment, fragmentNode, owner, snapshot) {
     };
   }
   if (snapshot.isMissingData) {
-    var pendingOperations = getPendingOperationsForFragment(environment, fragmentNode, owner);
-    if (pendingOperations != null) {
+    if (getObservableForActiveRequest(environment, owner) != null || environment.getOperationTracker().getPendingOperationsAffectingOwner(owner) != null) {
       return {
         state: 'loading'
       };
     }
   }
   try {
-    handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
+    handlePotentialSnapshotErrors(environment, snapshot.fieldErrors);
   } catch (error) {
     return {
       error: error,
@@ -97,6 +121,29 @@ function snapshotToFragmentState(environment, fragmentNode, owner, snapshot) {
     value: snapshot.data
   };
 }
+function mergeFragmentStates(states) {
+  var value = [];
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(states),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var state = _step.value;
+      if (state.state === 'ok') {
+        value.push(state.value);
+      } else {
+        return state;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    state: 'ok',
+    value: value
+  };
+}
 module.exports = {
   observeFragment: observeFragment,
   waitForFragmentData: waitForFragmentData

package/lib/store/observeQueryExperimental.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _require = require('./observeFragmentExperimental'),
+  observeFragment = _require.observeFragment;
+var _require2 = require('./RelayModernOperationDescriptor'),
+  createOperationDescriptor = _require2.createOperationDescriptor;
+function observeQuery(environment, gqlQuery, variables) {
+  var operation = createOperationDescriptor(gqlQuery, variables);
+  var rootFragmentRef = {
+    __id: operation.fragment.dataID,
+    __fragments: (0, _defineProperty2["default"])({}, operation.fragment.node.name, operation.request.variables),
+    __fragmentOwner: operation.request
+  };
+  var fragmentNode = operation.request.node.fragment;
+  return observeFragment(environment, fragmentNode, rootFragmentRef);
+}
+module.exports = {
+  observeQuery: observeQuery
+};

package/lib/util/RelayFeatureFlags.js

@@ -5,7 +5,6 @@ var RelayFeatureFlags = {
   ENABLE_RELAY_RESOLVERS: false,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
-  ENABLE_LOAD_QUERY_REQUEST_DEDUPING: true,
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: false,
   ENABLE_NOTIFY_SUBSCRIPTION: false,
   BATCH_ASYNC_MODULE_UPDATES_FN: null,
@@ -13,6 +12,8 @@ var RelayFeatureFlags = {
   MAX_DATA_ID_LENGTH: null,
   STRING_INTERN_LEVEL: 0,
   LOG_MISSING_RECORDS_IN_PROD: false,
+  ENABLE_STORE_ID_COLLISION_LOGGING: false,
+  ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS: false,
   ENABLE_LOOSE_SUBSCRIPTION_ATTRIBUTION: false,
   ENABLE_OPERATION_TRACKER_OPTIMISTIC_UPDATES: false,
   ENABLE_RELAY_OPERATION_TRACKER_SUSPENSE: false,
@@ -20,6 +21,10 @@ var RelayFeatureFlags = {
   MARK_RESOLVER_VALUES_AS_CLEAN_AFTER_FRAGMENT_REREAD: false,
   ENABLE_CYLE_DETECTION_IN_VARIABLES: false,
   ENABLE_ACTIVITY_COMPATIBILITY: false,
-  AVOID_CYCLES_IN_RESOLVER_NOTIFICATION: false
+  ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: true,
+  ENABLE_USE_PAGINATION_IS_LOADING_FIX: false,
+  DISALLOW_NESTED_UPDATES: false,
+  ENABLE_TYPENAME_PREFIXED_DATA_ID: false,
+  ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false
 };
 module.exports = RelayFeatureFlags;

package/lib/util/handlePotentialSnapshotErrors.js

@@ -1,22 +1,25 @@
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 var invariant = require('invariant');
-function handleFieldErrors(environment, errorResponseFields) {
-  var _iterator = (0, _createForOfIteratorHelper2["default"])(errorResponseFields),
+function handleFieldErrors(environment, fieldErrors, loggingContext) {
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(fieldErrors),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var fieldError = _step.value;
-      environment.relayFieldLogger(fieldError);
+      environment.relayFieldLogger((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, fieldError), {}, {
+        uiContext: loggingContext
+      }));
     }
   } catch (err) {
     _iterator.e(err);
   } finally {
     _iterator.f();
   }
-  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(errorResponseFields),
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(fieldErrors),
     _step2;
   try {
     for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
@@ -24,9 +27,9 @@ function handleFieldErrors(environment, errorResponseFields) {
       if (eventShouldThrow(_fieldError)) {
         switch (_fieldError.kind) {
           case 'relay_resolver.error':
-            throw new Error("Relay: Resolver error at path '".concat(_fieldError.fieldPath, "' in '").concat(_fieldError.owner, "'."));
+            throw new Error("Relay: Resolver error at path '".concat(_fieldError.fieldPath, "' in '").concat(_fieldError.owner, "'. Message: ").concat(_fieldError.error.message));
           case 'relay_field_payload.error':
-            throw new Error("Relay: Unexpected response payload - this object includes an errors property in which you can access the underlying errors");
+            throw new Error("Relay: Unexpected response payload - check server logs for details.");
           case 'missing_expected_data.throw':
             throw new Error("Relay: Missing expected data at path '".concat(_fieldError.fieldPath, "' in '").concat(_fieldError.owner, "'."));
           case 'missing_required_field.throw':
@@ -62,9 +65,9 @@ function eventShouldThrow(event) {
       throw new Error('Relay: Unexpected event kind');
   }
 }
-function handlePotentialSnapshotErrors(environment, errorResponseFields) {
-  if (errorResponseFields != null) {
-    handleFieldErrors(environment, errorResponseFields);
+function handlePotentialSnapshotErrors(environment, fieldErrors, loggingContext) {
+  if (fieldErrors != null) {
+    handleFieldErrors(environment, fieldErrors, loggingContext);
   }
 }
 module.exports = {

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

@@ -87,6 +87,7 @@ class ActorSpecificEnvironment implements IActorEnvironment {
       config.handlerProvider,
       defaultGetDataID,
       config.missingFieldHandlers,
+      this.__log,
     );
     this._defaultRenderPolicy = config.defaultRenderPolicy;
     // TODO:T92305692 Remove `options` in favor of directly using `actorIdentifier` on the environment

package/mutations/RelayRecordProxy.js.flow

@@ -11,6 +11,7 @@
 
 'use strict';
 
+import type {TRelayFieldError} from '../store/RelayErrorTrie';
 import type {RecordProxy} from '../store/RelayStoreTypes';
 import type {Arguments} from '../store/RelayStoreUtils';
 import type {DataID} from '../util/RelayRuntimeTypes';
@@ -65,22 +66,48 @@ class RelayRecordProxy implements RecordProxy {
     return this._mutator.getValue(this._dataID, storageKey);
   }
 
-  setValue(value: mixed, name: string, args?: ?Arguments): RecordProxy {
+  setValue(
+    value: mixed,
+    name: string,
+    args?: ?Arguments,
+    errors?: ?$ReadOnlyArray<TRelayFieldError>,
+  ): RecordProxy {
     invariant(
       isValidLeafValue(value),
       'RelayRecordProxy#setValue(): Expected a scalar or array of scalars, ' +
         'got `%s`.',
       JSON.stringify(value),
     );
-    return this.setValue__UNSAFE(value, name, args);
+
+    return this.setValue__UNSAFE(value, name, args, errors);
+  }
+
+  getErrors(
+    name: string,
+    args?: ?Arguments,
+  ): ?$ReadOnlyArray<TRelayFieldError> {
+    const storageKey = getStableStorageKey(name, args);
+    return this._mutator.getErrors(this._dataID, storageKey);
   }
 
   // This is used in the typesafe updaters.
   // We already validated that the value has the correct type
   // so it should be safe to store complex structures as scalar values (custom scalars)
-  setValue__UNSAFE(value: mixed, name: string, args?: ?Arguments): RecordProxy {
+  setValue__UNSAFE(
+    value: mixed,
+    name: string,
+    args?: ?Arguments,
+    errors?: ?$ReadOnlyArray<TRelayFieldError>,
+  ): RecordProxy {
     const storageKey = getStableStorageKey(name, args);
     this._mutator.setValue(this._dataID, storageKey, value);
+    if (errors != null) {
+      if (errors.length === 0) {
+        this._mutator.setErrors(this._dataID, storageKey);
+      } else {
+        this._mutator.setErrors(this._dataID, storageKey, errors);
+      }
+    }
     return this;
   }
 

package/mutations/RelayRecordSourceMutator.js.flow

@@ -11,6 +11,7 @@
 
 'use strict';
 
+import type {TRelayFieldError} from '../store/RelayErrorTrie';
 import type {RecordState} from '../store/RelayRecordState';
 import type {
   MutableRecordSource,
@@ -179,6 +180,32 @@ class RelayRecordSourceMutator {
     RelayModernRecord.setValue(sinkRecord, storageKey, value);
   }
 
+  getErrors(
+    dataID: DataID,
+    storageKey: string,
+  ): ?$ReadOnlyArray<TRelayFieldError> {
+    for (let ii = 0; ii < this.__sources.length; ii++) {
+      const record = this.__sources[ii].get(dataID);
+      if (record) {
+        const value = RelayModernRecord.getErrors(record, storageKey);
+        if (value !== undefined) {
+          return value;
+        }
+      } else if (record === null) {
+        return null;
+      }
+    }
+  }
+
+  setErrors(
+    dataID: DataID,
+    storageKey: string,
+    errors?: $ReadOnlyArray<TRelayFieldError>,
+  ): void {
+    const sinkRecord = this._getSinkRecord(dataID);
+    RelayModernRecord.setErrors(sinkRecord, storageKey, errors);
+  }
+
   getLinkedRecordID(dataID: DataID, storageKey: string): ?DataID {
     for (let ii = 0; ii < this.__sources.length; ii++) {
       const record = this.__sources[ii].get(dataID);

package/mutations/RelayRecordSourceProxy.js.flow

@@ -18,6 +18,7 @@ import type {
   FragmentType,
   HandleFieldPayload,
   HasUpdatableSpread,
+  LogFunction,
   MissingFieldHandler,
   RecordProxy,
   RecordSource,
@@ -53,12 +54,14 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
   _invalidatedStore: boolean;
   _idsMarkedForInvalidation: DataIDSet;
   _missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>;
+  _log: LogFunction;
 
   constructor(
     mutator: RelayRecordSourceMutator,
     getDataID: GetDataID,
     handlerProvider?: ?HandlerProvider,
     missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+    log: ?LogFunction,
   ) {
     this.__mutator = mutator;
     this._handlerProvider = handlerProvider || null;
@@ -67,6 +70,7 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
     this._invalidatedStore = false;
     this._idsMarkedForInvalidation = new Set();
     this._missingFieldHandlers = missingFieldHandlers;
+    this._log = log ?? (LogEvent => {});
   }
 
   publishSource(

package/mutations/createUpdatableProxy.js.flow

@@ -181,11 +181,11 @@ function updateProxyFromSelections<TData>(
       case 'ClientEdgeToServerObject':
       case 'Defer':
       case 'ModuleImport':
-      case 'RelayLiveResolver':
       case 'RequiredField':
       case 'CatchField':
       case 'Stream':
       case 'RelayResolver':
+      case 'RelayLiveResolver':
         // These types of reader nodes are not currently handled.
         throw new Error(
           'Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.',

package/mutations/validateMutation.js.flow

@@ -145,13 +145,13 @@ if (__DEV__) {
         return validateModuleImport(context);
       case 'TypeDiscriminator':
         return validateAbstractKey(context, selection.abstractKey);
-      case 'RelayResolver':
-      case 'RelayLiveResolver':
       case 'ClientEdgeToClientObject':
       case 'LinkedHandle':
       case 'ScalarHandle':
       case 'Defer':
-      case 'Stream': {
+      case 'Stream':
+      case 'RelayResolver':
+      case 'RelayLiveResolver': {
         // TODO(T35864292) - Add missing validations for these types
         return;
       }

package/network/RelayNetworkTypes.js.flow

@@ -11,6 +11,7 @@
 
 'use strict';
 
+import type {OperationAvailability} from '../store/RelayStoreTypes';
 import type {RequestParameters} from '../util/RelayConcreteNode';
 import type {CacheConfig, Variables} from '../util/RelayRuntimeTypes';
 import type RelayObservable, {ObservableFromValue} from './RelayObservable';
@@ -104,6 +105,8 @@ export type ExecuteFunction = (
   logRequestInfo?: ?LogRequestInfoFunction,
   encryptedVariables?: ?string,
   preprocessResponse?: ?preprocessResponseFunction,
+  // Run datachecker on the current operation and returns the OperationAvailability
+  checkOperation?: () => OperationAvailability,
 ) => RelayObservable<GraphQLResponse>;
 
 /**

package/network/RelayObservable.js.flow

@@ -614,11 +614,7 @@ if (__DEV__) {
   // Default implementation of HostReportErrors() in development builds.
   // Can be replaced by the host application environment.
   RelayObservable.onUnhandledError((error, isUncaughtThrownError) => {
-    declare function fail(string): void;
-    if (typeof fail === 'function') {
-      // In test environments (Jest), fail() immediately fails the current test.
-      fail(String(error));
-    } else if (isUncaughtThrownError) {
+    if (isUncaughtThrownError) {
       // Rethrow uncaught thrown errors on the next frame to avoid breaking
       // current logic.
       setTimeout(() => {

package/network/wrapNetworkWithLogObserver.js.flow

@@ -12,12 +12,17 @@
 'use strict';
 import type ActorSpecificEnvironment from '../multi-actor-environment/ActorSpecificEnvironment';
 import type RelayModernEnvironment from '../store/RelayModernEnvironment';
+import type {
+  LogRequestInfoFunction,
+  OperationAvailability,
+} from '../store/RelayStoreTypes';
 import type {RequestParameters} from '../util/RelayConcreteNode';
 import type {CacheConfig, Variables} from '../util/RelayRuntimeTypes';
 import type {
   GraphQLResponse,
   INetwork,
   UploadableMap,
+  preprocessResponseFunction,
 } from './RelayNetworkTypes';
 import type RelayObservable from './RelayObservable';
 import type {Subscription} from './RelayObservable';
@@ -42,6 +47,10 @@ function wrapNetworkWithLogObserver(
       variables: Variables,
       cacheConfig: CacheConfig,
       uploadables?: ?UploadableMap,
+      _?: ?LogRequestInfoFunction,
+      encryptedVariables?: ?string,
+      preprocessResponse?: ?preprocessResponseFunction,
+      checkOperation?: () => OperationAvailability,
     ): RelayObservable<GraphQLResponse> {
       const networkRequestId = generateID();
       const logObserver = {
@@ -89,7 +98,16 @@ function wrapNetworkWithLogObserver(
         });
       };
       return network
-        .execute(params, variables, cacheConfig, uploadables, logRequestInfo)
+        .execute(
+          params,
+          variables,
+          cacheConfig,
+          uploadables,
+          logRequestInfo,
+          encryptedVariables,
+          preprocessResponse,
+          checkOperation,
+        )
         .do(logObserver);
     },
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "18.1.0",
+  "version": "19.0.0",
   "keywords": [
     "graphql",
     "relay"

package/query/fetchQuery.js.flow

@@ -138,7 +138,7 @@ function fetchQuery<TVariables: Variables, TData, TRawResponse>(
   const fetchPolicy = options?.fetchPolicy ?? 'network-only';
 
   function readData(snapshot: Snapshot): TData {
-    handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
+    handlePotentialSnapshotErrors(environment, snapshot.fieldErrors);
     /* $FlowFixMe[incompatible-return] we assume readData returns the right
      * data just having written it from network or checked availability. */
     return snapshot.data;

package/store/DataChecker.js.flow

@@ -90,6 +90,7 @@ function check(
     operationLoader,
     getDataID,
     shouldProcessClientComponents,
+    log,
   );
   const result = checker.check(node, dataID);
   if (log != null) {
@@ -123,6 +124,7 @@ class DataChecker {
     ActorIdentifier,
     [RelayRecordSourceMutator, RelayRecordSourceProxy],
   >;
+  _log: ?LogFunction;
 
   constructor(
     getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource,
@@ -135,6 +137,7 @@ class DataChecker {
     operationLoader: ?OperationLoader,
     getDataID: GetDataID,
     shouldProcessClientComponents: ?boolean,
+    log: ?LogFunction,
   ) {
     this._getSourceForActor = getSourceForActor;
     this._getTargetForActor = getTargetForActor;
@@ -152,6 +155,7 @@ class DataChecker {
     this._recordWasMissing = false;
     this._variables = variables;
     this._shouldProcessClientComponents = shouldProcessClientComponents;
+    this._log = log;
   }
 
   _getMutatorAndRecordProxyForActor(
@@ -170,6 +174,7 @@ class DataChecker {
         this._getDataID,
         undefined,
         this._handlers,
+        this._log,
       );
       tuple = [mutator, recordSourceProxy];
       this._mutatorRecordSourceProxyCache.set(actorIdentifier, tuple);
@@ -449,8 +454,6 @@ class DataChecker {
           this._traverseSelections(selection.fragment.selections, dataID);
           break;
         case 'RelayResolver':
-          this._checkResolver(selection, dataID);
-          break;
         case 'RelayLiveResolver':
           this._checkResolver(selection, dataID);
           break;

package/store/OperationExecutor.js.flow

@@ -245,6 +245,12 @@ class Executor<TMutation: MutationParameters> {
           cacheConfig: this._operation.request.cacheConfig ?? {},
         });
       },
+      unsubscribe: () => {
+        this._log({
+          name: 'execute.unsubscribe',
+          executeId: this._executeId,
+        });
+      },
     });
 
     if (
@@ -293,7 +299,7 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _updateActiveState(): void {
-    let activeState;
+    let activeState: ActiveState;
     switch (this._state) {
       case 'started': {
         activeState = 'active';
@@ -606,6 +612,7 @@ class Executor<TMutation: MutationParameters> {
         {
           actorIdentifier: this._actorIdentifier,
           getDataID: this._getDataID,
+          log: this._log,
           path: [],
           shouldProcessClientComponents: this._shouldProcessClientComponents,
           treatMissingFieldsAsNull,
@@ -715,6 +722,7 @@ class Executor<TMutation: MutationParameters> {
       {
         actorIdentifier: this._actorIdentifier,
         getDataID: this._getDataID,
+        log: this._log,
         path: followupPayload.path,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
@@ -797,6 +805,7 @@ class Executor<TMutation: MutationParameters> {
         {
           actorIdentifier: this._actorIdentifier,
           getDataID: this._getDataID,
+          log: this._log,
           path: [],
           treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           shouldProcessClientComponents: this._shouldProcessClientComponents,
@@ -1253,6 +1262,7 @@ class Executor<TMutation: MutationParameters> {
       {
         actorIdentifier: this._actorIdentifier,
         getDataID: this._getDataID,
+        log: this._log,
         path: placeholder.path,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
@@ -1480,6 +1490,7 @@ class Executor<TMutation: MutationParameters> {
     const relayPayload = this._normalizeResponse(response, selector, typeName, {
       actorIdentifier: this._actorIdentifier,
       getDataID: this._getDataID,
+      log: this._log,
       path: [...normalizationPath, responseKey, String(itemIndex)],
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       shouldProcessClientComponents: this._shouldProcessClientComponents,

package/store/RelayExperimentalGraphResponseTransform.js.flow

@@ -222,10 +222,10 @@ export class GraphModeNormalizer {
       $streamID,
       __id: dataID,
       __typename: ROOT_TYPE,
-    };
+    } as RecordChunk;
     yield {
       $kind: 'Complete',
-    };
+    } as CompleteChunk;
   }
 
   *_flushFields(
@@ -247,9 +247,9 @@ export class GraphModeNormalizer {
         __typename: typename,
         __id: cacheKey,
         $streamID,
-      };
+      } as RecordChunk;
     } else if (Object.keys(fields).length > 0) {
-      yield {...fields, $kind: 'Extend', $streamID};
+      yield {...fields, $kind: 'Extend', $streamID} as ExtendChunk;
     }
     return $streamID;
   }