relay-runtime 18.1.0 → 19.0.0

package/store/observeFragmentExperimental.js.flow

@@ -9,7 +9,7 @@
  * @oncall relay
  */
 
-import type {RequestDescriptor} from './RelayStoreTypes';
+import type {PluralReaderSelector, RequestDescriptor} from './RelayStoreTypes';
 import type {
   Fragment,
   FragmentType,
@@ -20,8 +20,8 @@ import type {
 } from 'relay-runtime';
 
 const Observable = require('../network/RelayObservable');
+const {getObservableForActiveRequest} = require('../query/fetchQueryInternal');
 const {getFragment} = require('../query/GraphQLTag');
-const getPendingOperationsForFragment = require('../util/getPendingOperationsForFragment');
 const {
   handlePotentialSnapshotErrors,
 } = require('../util/handlePotentialSnapshotErrors');
@@ -47,8 +47,7 @@ export type HasSpread<TFragmentType> = {
 
 /**
  * EXPERIMENTAL: This API is experimental and does not yet support all Relay
- * features. Notably, it does not correectly handle plural fragments or some
- * features of Relay Resolvers.
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
  *
  * Given a fragment and a fragment reference, returns a promise that resolves
  * once the fragment data is available, or rejects if the fragment has an error.
@@ -63,7 +62,9 @@ export type HasSpread<TFragmentType> = {
 async function waitForFragmentData<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: HasSpread<TFragmentType>,
+  fragmentRef:
+    | HasSpread<TFragmentType>
+    | $ReadOnlyArray<HasSpread<TFragmentType>>,
 ): Promise<TData> {
   let subscription: ?Subscription;
 
@@ -94,13 +95,14 @@ async function waitForFragmentData<TFragmentType: FragmentType, TData>(
 declare function observeFragment<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: HasSpread<TFragmentType>,
+  fragmentRef:
+    | HasSpread<TFragmentType>
+    | $ReadOnlyArray<HasSpread<TFragmentType>>,
 ): Observable<FragmentState<TData>>;
 
 /**
  * EXPERIMENTAL: This API is experimental and does not yet support all Relay
- * features. Notably, it does not correectly handle plural fragments or some
- * features of Relay Resolvers.
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
  *
  * Given a fragment and a fragment reference, returns an observable that emits
  * the state of the fragment over time. The observable will emit the following
@@ -114,7 +116,7 @@ function observeFragment<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
   fragmentRef: mixed,
-): Observable<FragmentState<TData>> {
+): mixed {
   const fragmentNode = getFragment(fragment);
   const fragmentSelector = getSelector(fragmentNode, fragmentRef);
   invariant(
@@ -124,24 +126,19 @@ function observeFragment<TFragmentType: FragmentType, TData>(
   invariant(fragmentSelector != null, 'Expected a selector, got null.');
   switch (fragmentSelector.kind) {
     case 'SingularReaderSelector':
-      return observeSelector(environment, fragment, fragmentSelector);
+      return observeSingularSelector(environment, fragment, fragmentSelector);
     case 'PluralReaderSelector': {
-      // TODO: We could use something like this RXJS's combineLatest to create
-      // an observable for each selector and merge them.
-      // https://github.com/ReactiveX/rxjs/blob/master/packages/rxjs/src/internal/observable/combineLatest.ts
-      //
-      // Note that this problem is a bit tricky because Relay currently only
-      // lets you subscribe at a singular fragment granularity. This makes it
-      // hard to batch updates such that when a store update causes multiple
-      // fragments to change, we can only publish a single update to the
-      // fragment owner.
-      invariant(false, 'Plural fragments are not supported');
+      return observePluralSelector(
+        environment,
+        (fragment: $FlowFixMe),
+        fragmentSelector,
+      );
     }
   }
   invariant(false, 'Unsupported fragment selector kind');
 }
 
-function observeSelector<TFragmentType: FragmentType, TData>(
+function observeSingularSelector<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
   fragmentSelector: SingularReaderSelector,
@@ -173,6 +170,49 @@ function observeSelector<TFragmentType: FragmentType, TData>(
   });
 }
 
+function observePluralSelector<
+  TFragmentType: FragmentType,
+  TData: Array<mixed>,
+>(
+  environment: IEnvironment,
+  fragmentNode: Fragment<TFragmentType, TData>,
+  fragmentSelector: PluralReaderSelector,
+): Observable<FragmentState<TData>> {
+  const snapshots = fragmentSelector.selectors.map(selector =>
+    environment.lookup(selector),
+  );
+
+  return Observable.create(sink => {
+    // This array is mutable since each subscription updates the array in place.
+    const states = snapshots.map((snapshot, index) =>
+      snapshotToFragmentState(
+        environment,
+        fragmentNode,
+        fragmentSelector.selectors[index].owner,
+        snapshot,
+      ),
+    );
+
+    sink.next((mergeFragmentStates(states): $FlowFixMe));
+
+    const subscriptions = snapshots.map((snapshot, index) =>
+      environment.subscribe(snapshot, latestSnapshot => {
+        states[index] = snapshotToFragmentState(
+          environment,
+          fragmentNode,
+          fragmentSelector.selectors[index].owner,
+          latestSnapshot,
+        );
+        // This doesn't batch updates, so it will notify the subscriber multiple times
+        // if a store update impacting multiple items in the list is published.
+        sink.next((mergeFragmentStates(states): $FlowFixMe));
+      }),
+    );
+
+    return () => subscriptions.forEach(subscription => subscription.dispose());
+  });
+}
+
 function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
@@ -201,18 +241,18 @@ function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
   }
 
   if (snapshot.isMissingData) {
-    const 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, state: 'error'};
   }
@@ -229,6 +269,20 @@ function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
   return {state: 'ok', value: (snapshot.data: $FlowFixMe)};
 }
 
+function mergeFragmentStates<T>(
+  states: $ReadOnlyArray<FragmentState<T>>,
+): FragmentState<Array<T>> {
+  const value = [];
+  for (const state of states) {
+    if (state.state === 'ok') {
+      value.push(state.value);
+    } else {
+      return state;
+    }
+  }
+  return {state: 'ok', value};
+}
+
 module.exports = {
   observeFragment,
   waitForFragmentData,

package/store/observeQueryExperimental.js.flow

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type RelayObservable from '../network/RelayObservable';
+import type {FragmentState} from './observeFragmentExperimental';
+import type {OperationDescriptor} from './RelayStoreTypes';
+import type {Fragment, IEnvironment, Query, Variables} from 'relay-runtime';
+
+const {observeFragment} = require('./observeFragmentExperimental');
+const {createOperationDescriptor} = require('./RelayModernOperationDescriptor');
+
+/**
+ * This function returns an observable that can be used to subscribe to the data
+ * contained in a query. It does not return the full response shape, but rather
+ * the contents of the query body minus any fragment spreads.  If you wish to
+ * read the contents of a fragment spread into this query you may pass the
+ * object into which the fragment was spread to `observeFragment`.
+ *
+ * NOTE: `observeQuery` assumes that you have already fetched and retained the
+ * query via some other means, such as `fetchQuery`.
+ *
+ * This feature is still experimental and does not properly handle some resolver
+ * features such as client-to-server edges.
+ */
+function observeQuery<TVariables: Variables, TData>(
+  environment: IEnvironment,
+  gqlQuery: Query<TVariables, TData>,
+  variables: TVariables,
+): RelayObservable<FragmentState<TData>> {
+  const operation: OperationDescriptor = createOperationDescriptor(
+    gqlQuery,
+    variables,
+  );
+
+  const rootFragmentRef: $FlowFixMe = {
+    __id: operation.fragment.dataID,
+    __fragments: {
+      [operation.fragment.node.name]: operation.request.variables,
+    },
+    __fragmentOwner: operation.request,
+  };
+
+  const fragmentNode: Fragment<$FlowFixMe, TData> = (operation.request.node
+    .fragment: $FlowFixMe);
+
+  return observeFragment(environment, fragmentNode, rootFragmentRef);
+}
+
+module.exports = {
+  observeQuery,
+};

package/store/waitForFragmentExperimental.js.flow

@@ -21,8 +21,7 @@ const {observeFragment} = require('./observeFragmentExperimental');
 
 /**
  * EXPERIMENTAL: This API is experimental and does not yet support all Relay
- * features. Notably, it does not correectly handle plural fragments or some
- * features of Relay Resolvers.
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
  *
  * Given a fragment and a fragment reference, returns a promise that resolves
  * once the fragment data is available, or rejects if the fragment has an error.
@@ -37,7 +36,9 @@ const {observeFragment} = require('./observeFragmentExperimental');
 async function waitForFragmentData<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: HasSpread<TFragmentType>,
+  fragmentRef:
+    | HasSpread<TFragmentType>
+    | $ReadOnlyArray<HasSpread<TFragmentType>>,
 ): Promise<TData> {
   let subscription: ?Subscription;
 

package/util/NormalizationNode.js.flow

@@ -12,7 +12,7 @@
 'use strict';
 
 import type {ResolverFunction, ResolverModule} from './ReaderNode';
-import type {ConcreteRequest} from './RelayConcreteNode';
+import type {ConcreteRequest, ProvidedVariableType} from './RelayConcreteNode';
 import type {JSResourceReference} from 'JSResourceReference';
 
 /**
@@ -27,6 +27,8 @@ export type NormalizationOperation = {
   +clientAbstractTypes?: {
     +[string]: $ReadOnlyArray<string>,
   },
+  +use_exec_time_resolvers?: boolean,
+  +exec_time_resolvers_enabled_provider?: ProvidedVariableType,
 };
 
 export type NormalizationHandle =
@@ -200,10 +202,17 @@ export type NormalizationLiveResolverField = {
   ...ResolverData,
 };
 
+export type NormalizationModelResolvers = {
+  [string]: {
+    +resolverModule: ResolverModule,
+  },
+};
+
 export type NormalizationClientEdgeToClientObject = {
   +kind: 'ClientEdgeToClientObject',
   +linkedField: NormalizationLinkedField,
   +backingField: NormalizationResolverField | NormalizationLiveResolverField,
+  +modelResolvers?: NormalizationModelResolvers | null,
 };
 
 export type NormalizationClientComponent = {

package/util/ReaderNode.js.flow

@@ -37,7 +37,10 @@ export type ReaderFragment = {
   +abstractKey?: ?string,
   +metadata?: ?{
     +connection?: $ReadOnlyArray<ConnectionMetadata>,
+    // Indicates if the fragment has been annotated with `@throwOnFieldError`
     +throwOnFieldError?: boolean,
+    // Indicates if the fragment has been annotated with `@catch`
+    +catchTo?: CatchFieldTo,
     +hasClientEdges?: boolean,
     +mask?: boolean,
     +plural?: boolean,
@@ -80,6 +83,7 @@ export type ReaderRefetchMetadata = {
   +operation: string | ConcreteRequest,
   +fragmentPathInResult: Array<string>,
   +identifierInfo?: ?RefetchableIdentifierInfo,
+  +edgesFragment?: ReaderFragment,
 };
 
 // Stricter form of ConnectionMetadata
@@ -231,16 +235,18 @@ export type ReaderRequiredField = {
   +kind: 'RequiredField',
   +field: ReaderField | ReaderClientEdge,
   +action: RequiredFieldAction,
-  +path: string,
+  // TODO: This field is not used any more, we should be able to remove it.
+  +path?: mixed,
 };
 
 export type CatchFieldTo = 'RESULT' | 'NULL';
 
 export type ReaderCatchField = {
   +kind: 'CatchField',
-  +field: ReaderField | ReaderClientEdge,
+  +field: ReaderField | ReaderClientEdge | ReaderAliasedInlineFragmentSpread,
   +to: CatchFieldTo,
-  +path: string,
+  // TODO: This field is not used any more, we should be able to remove it.
+  +path?: mixed,
 };
 
 export type ResolverFunction = (...args: Array<any>) => mixed; // flowlint-line unclear-type:off

package/util/RelayConcreteNode.js.flow

@@ -39,6 +39,8 @@ export type NormalizationRootNode =
   | ConcreteRequest
   | NormalizationSplitOperation;
 
+export type ProvidedVariableType = {get(): mixed};
+
 export type ProvidedVariablesType = {+[key: string]: {get(): mixed}};
 
 /**
@@ -130,6 +132,6 @@ const RelayConcreteNode = {
   TYPE_DISCRIMINATOR: 'TypeDiscriminator',
   UPDATABLE_QUERY: 'UpdatableQuery',
   VARIABLE: 'Variable',
-};
+} as const;
 
 module.exports = RelayConcreteNode;

package/util/RelayError.js.flow

@@ -25,6 +25,7 @@ function createError(
     String(messageParams[index++]),
   );
   const err = new Error(message);
+  // $FlowFixMe[unsafe-object-assign]
   const error = Object.assign((err: any), {
     name,
     messageFormat,

package/util/RelayFeatureFlags.js.flow

@@ -18,7 +18,6 @@ export type FeatureFlags = {
   ENABLE_RELAY_RESOLVERS: boolean,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean,
-  ENABLE_LOAD_QUERY_REQUEST_DEDUPING: boolean,
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: boolean,
   ENABLE_NOTIFY_SUBSCRIPTION: boolean,
   BATCH_ASYNC_MODULE_UPDATES_FN: ?(() => void) => Disposable,
@@ -27,6 +26,15 @@ export type FeatureFlags = {
   STRING_INTERN_LEVEL: number,
   LOG_MISSING_RECORDS_IN_PROD: boolean,
   ENABLE_RELAY_OPERATION_TRACKER_SUSPENSE: boolean,
+  ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: boolean,
+
+  // Some GraphQL servers are noncompliant with the GraphQL specification and
+  // return an empty list instead of null when there is a field error on a list.
+  //
+  // If this describes your server, enable this flag so that Relay will treat
+  // empty lists as null when deciding whether or not to check for field errors
+  // in the response.
+  ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS: boolean,
 
   // Configure RelayStoreSubscriptions to mark a subscription as affected by an
   // update if there are any overlapping IDs other than ROOT_ID or VIWER_ID,
@@ -48,10 +56,21 @@ export type FeatureFlags = {
   // Temporary flag to experiment to enable compatibility with React's unstable <Activity> API
   ENABLE_ACTIVITY_COMPATIBILITY: boolean,
 
-  // Gating a fix to prevent infinite loops when invalidating Relay Resolvers.
-  // We believe the fix to be correct but don't yet have a test to validate it
-  // fixes the error, so we're gating it for now.
-  AVOID_CYCLES_IN_RESOLVER_NOTIFICATION: boolean,
+  // Adds a prefix to the storage key of read time resolvers. This is used to
+  // disambiguate the same resolver being used at both read time and exec time.
+  ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: boolean,
+
+  // Enable the fix for usePaginationFragment stucking in loading state
+  ENABLE_USE_PAGINATION_IS_LOADING_FIX: boolean,
+
+  // Enable logging an ID collision in the Relay store
+  ENABLE_STORE_ID_COLLISION_LOGGING: boolean,
+
+  // Throw on nested store updates
+  DISALLOW_NESTED_UPDATES: boolean,
+
+  // Enable prefixing of DataID in the store with __typename
+  ENABLE_TYPENAME_PREFIXED_DATA_ID: boolean,
 };
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -59,7 +78,6 @@ const RelayFeatureFlags: FeatureFlags = {
   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,
@@ -67,6 +85,8 @@ const RelayFeatureFlags: FeatureFlags = {
   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,
@@ -74,7 +94,11 @@ const RelayFeatureFlags: FeatureFlags = {
   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/util/RelayRuntimeTypes.js.flow

@@ -53,9 +53,10 @@ export type VariablesOf<T: OperationType> = T['variables'];
  *   state of any configured response cache.
  * - `poll`: causes a query to live update by polling at the specified interval
  *   in milliseconds. (This value will be passed to setTimeout.)
- * - `liveConfigId`: causes a query to live update by calling GraphQLLiveQuery,
- *   it represents a configuration of gateway when doing live query
- * - `onSubscribe`: Not in use.
+ * - `liveConfigId`: Makes a query live by sending through RTI stack.
+ * - `onSubscribe`: Callback to be called when a live query stream is started.
+ * - `onPause`: Callback to be called when a live query stream is paused, e.g. due to a network disconnection.
+ * - `onResume`: Callback to be called when a live query stream is resumed, e.g. from a network disconnection.
  * - `metadata`: user-supplied metadata.
  * - `transactionId`: a user-supplied value, intended for use as a unique id for
  *   a given instance of executing an operation.
@@ -65,6 +66,8 @@ export type CacheConfig = {
   poll?: ?number,
   liveConfigId?: ?string,
   onSubscribe?: () => void,
+  onResume?: (pauseTimeMs: number) => void,
+  onPause?: (mqttConnectionIsOk: boolean, internetIsOk: boolean) => void,
   metadata?: {[key: string]: mixed, ...},
   transactionId?: ?string,
 };
@@ -165,3 +168,14 @@ declare export opaque type RefetchableFragment<
   +TData,
   TVariables: Variables,
 >: Fragment<TFragmentType, TData>;
+
+/**
+ * Return type of graphql tag literals for `@refetchable` fragments
+ * with prefetchable pagination connections.
+ */
+declare export opaque type PrefetchableRefetchableFragment<
+  TFragmentType,
+  +TData,
+  +TEdgeData,
+  TVariables: Variables,
+>: Fragment<TFragmentType, TData>;

package/util/getPaginationVariables.js.flow

@@ -56,6 +56,7 @@ function getPaginationVariables(
       ...baseVariables,
       ...extraVariables,
       [backwardMetadata.cursor]: cursor,
+      // $FlowFixMe[incompatible-type]
       [backwardMetadata.count]: count,
     };
     if (forwardMetadata && forwardMetadata.cursor) {
@@ -92,6 +93,7 @@ function getPaginationVariables(
     ...baseVariables,
     ...extraVariables,
     [forwardMetadata.cursor]: cursor,
+    // $FlowFixMe[incompatible-type]
     [forwardMetadata.count]: count,
   };
   if (backwardMetadata && backwardMetadata.cursor) {

package/util/handlePotentialSnapshotErrors.js.flow

@@ -12,8 +12,8 @@
 'use strict';
 
 import type {
-  ErrorResponseField,
-  ErrorResponseFields,
+  FieldError,
+  FieldErrors,
   IEnvironment,
 } from '../store/RelayStoreTypes';
 
@@ -21,25 +21,36 @@ const invariant = require('invariant');
 
 function handleFieldErrors(
   environment: IEnvironment,
-  errorResponseFields: ErrorResponseFields,
+  fieldErrors: FieldErrors,
+  loggingContext: mixed | void,
 ) {
-  for (const fieldError of errorResponseFields) {
+  for (const fieldError of fieldErrors) {
     // First we log all events. Note that the logger may opt to throw its own
     // error here if it wants to throw an error that is better integrated into
     // site's error handling infrastructure.
-    environment.relayFieldLogger(fieldError);
+
+    // Awkward. We don't want to attach the ui context in RelayReader where we
+    // create the event, but it means we need to add it here instead of just
+    // passing the event through.
+
+    environment.relayFieldLogger({
+      // the uiContext on fieldError undefined *always*,
+      ...fieldError,
+      // and this is where we assign loggingContext to uiContext to populate it
+      uiContext: loggingContext,
+    });
   }
 
-  for (const fieldError of errorResponseFields) {
+  for (const fieldError of fieldErrors) {
     if (eventShouldThrow(fieldError)) {
       switch (fieldError.kind) {
         case 'relay_resolver.error':
           throw new Error(
-            `Relay: Resolver error at path '${fieldError.fieldPath}' in '${fieldError.owner}'.`,
+            `Relay: Resolver error at path '${fieldError.fieldPath}' in '${fieldError.owner}'. Message: ${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`,
+            `Relay: Unexpected response payload - check server logs for details.`,
           );
         case 'missing_expected_data.throw':
           throw new Error(
@@ -63,7 +74,7 @@ function handleFieldErrors(
   }
 }
 
-function eventShouldThrow(event: ErrorResponseField): boolean {
+function eventShouldThrow(event: FieldError): boolean {
   switch (event.kind) {
     case 'relay_resolver.error':
     case 'relay_field_payload.error':
@@ -82,14 +93,15 @@ function eventShouldThrow(event: ErrorResponseField): boolean {
 
 function handlePotentialSnapshotErrors(
   environment: IEnvironment,
-  errorResponseFields: ?ErrorResponseFields,
+  fieldErrors: ?FieldErrors,
+  loggingContext: mixed | void,
 ) {
   /**
    * Inside handleFieldErrors, we check for throwOnFieldError - but this fn logs the error anyway by default
    * which is why this still should run in any case there's errors.
    */
-  if (errorResponseFields != null) {
-    handleFieldErrors(environment, errorResponseFields);
+  if (fieldErrors != null) {
+    handleFieldErrors(environment, fieldErrors, loggingContext);
   }
 }
 

package/util/registerEnvironmentWithDevTools.js.flow

@@ -19,8 +19,10 @@ function registerEnvironmentWithDevTools(environment: IEnvironment): void {
   const _global =
     typeof global !== 'undefined'
       ? global
-      : typeof window !== 'undefined'
-        ? window
+      : // $FlowFixMe[cannot-resolve-name]
+        typeof window !== 'undefined'
+        ? // $FlowFixMe[cannot-resolve-name]
+          window
         : undefined;
 
   // $FlowFixMe[incompatible-use] D61394600

package/util/withProvidedVariables.js.flow

@@ -30,6 +30,7 @@ function withProvidedVariables(
 ): Variables {
   if (providedVariables != null) {
     const operationVariables: {[string]: mixed} = {};
+    // $FlowFixMe[unsafe-object-assign]
     Object.assign(operationVariables, userSuppliedVariables);
     Object.keys(providedVariables).forEach((varName: string) => {
       const providerFunction = providedVariables[varName].get;

package/util/withStartAndDuration.js.flow

@@ -12,11 +12,14 @@
 'use strict';
 
 const isPerformanceNowAvailable =
+  // $FlowFixMe[cannot-resolve-name]
   typeof window !== 'undefined' &&
+  // $FlowFixMe[cannot-resolve-name]
   typeof window?.performance?.now === 'function';
 
 function currentTimestamp(): number {
   if (isPerformanceNowAvailable) {
+    // $FlowFixMe[cannot-resolve-name]
     return window.performance.now();
   }
   return Date.now();