relay-runtime 0.0.0-main-1decb243 → 0.0.0-main-c52ed92a

package/store/DataChecker.js.flow

@@ -14,6 +14,7 @@
 import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {
   NormalizationLinkedField,
+  NormalizationLiveResolverField,
   NormalizationModuleImport,
   NormalizationNode,
   NormalizationResolverField,
@@ -62,6 +63,7 @@ const {
   LINKED_HANDLE,
   MODULE_IMPORT,
   RELAY_RESOLVER,
+  RELAY_LIVE_RESOLVER,
   SCALAR_FIELD,
   SCALAR_HANDLE,
   STREAM,
@@ -455,6 +457,9 @@ class DataChecker {
         case RELAY_RESOLVER:
           this._checkResolver(selection, dataID);
           break;
+        case RELAY_LIVE_RESOLVER:
+          this._checkResolver(selection, dataID);
+          break;
         case CLIENT_EDGE_TO_CLIENT_OBJECT:
           this._checkResolver(selection.backingField, dataID);
           break;
@@ -468,7 +473,10 @@ class DataChecker {
       }
     });
   }
-  _checkResolver(resolver: NormalizationResolverField, dataID: DataID) {
+  _checkResolver(
+    resolver: NormalizationResolverField | NormalizationLiveResolverField,
+    dataID: DataID,
+  ) {
     if (resolver.fragment) {
       this._traverseSelections([resolver.fragment], dataID);
     }

package/store/RelayModernSelector.js.flow

@@ -27,9 +27,9 @@ const {getFragmentVariables} = require('./RelayConcreteVariables');
 const {
   CLIENT_EDGE_TRAVERSAL_PATH,
   FRAGMENT_OWNER_KEY,
+  FRAGMENT_POINTER_IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
   FRAGMENTS_KEY,
   ID_KEY,
-  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
 } = require('./RelayStoreUtils');
 const areEqual = require('areEqual');
 const invariant = require('invariant');
@@ -78,8 +78,6 @@ function getSingularSelector(
   const dataID = item[ID_KEY];
   const fragments = item[FRAGMENTS_KEY];
   const mixedOwner = item[FRAGMENT_OWNER_KEY];
-  const isWithinUnmatchedTypeRefinement =
-    item[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] === true;
   const mixedClientEdgeTraversalPath = item[CLIENT_EDGE_TRAVERSAL_PATH];
   if (
     typeof dataID === 'string' &&
@@ -103,6 +101,11 @@ function getSingularSelector(
       argumentVariables,
     );
 
+    const isWithinUnmatchedTypeRefinement =
+      argumentVariables[
+        FRAGMENT_POINTER_IS_WITHIN_UNMATCHED_TYPE_REFINEMENT
+      ] === true;
+
     return createReaderSelector(
       fragment,
       dataID,

package/store/RelayReader.js.flow

@@ -79,7 +79,6 @@ const {
   FRAGMENT_PROP_NAME_KEY,
   FRAGMENTS_KEY,
   ID_KEY,
-  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
   MODULE_COMPONENT_KEY,
   ROOT_ID,
   getArgumentValues,
@@ -1065,7 +1064,7 @@ class RelayReader {
     let fragmentPointers = data[FRAGMENTS_KEY];
     if (fragmentPointers == null) {
       fragmentPointers = data[FRAGMENTS_KEY] = ({}: {
-        [string]: Arguments | {...},
+        [string]: Arguments,
       });
     }
     invariant(
@@ -1073,16 +1072,17 @@ class RelayReader {
       'RelayReader: Expected fragment spread data to be an object, got `%s`.',
       fragmentPointers,
     );
+
     if (data[ID_KEY] == null) {
       data[ID_KEY] = RelayModernRecord.getDataID(record);
     }
     // $FlowFixMe[cannot-write] - writing into read-only field
-    fragmentPointers[fragmentSpread.name] = fragmentSpread.args
-      ? getArgumentValues(fragmentSpread.args, this._variables)
-      : {};
+    fragmentPointers[fragmentSpread.name] = getArgumentValues(
+      fragmentSpread.args,
+      this._variables,
+      this._isWithinUnmatchedTypeRefinement,
+    );
     data[FRAGMENT_OWNER_KEY] = this._owner;
-    data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] =
-      this._isWithinUnmatchedTypeRefinement;
 
     if (RelayFeatureFlags.ENABLE_CLIENT_EDGES) {
       if (

package/store/RelayReferenceMarker.js.flow

@@ -14,6 +14,7 @@
 import type {
   NormalizationClientEdgeToClientObject,
   NormalizationLinkedField,
+  NormalizationLiveResolverField,
   NormalizationModuleImport,
   NormalizationNode,
   NormalizationResolverField,
@@ -54,6 +55,7 @@ const {
   STREAM,
   TYPE_DISCRIMINATOR,
   RELAY_RESOLVER,
+  RELAY_LIVE_RESOLVER,
   CLIENT_EDGE_TO_CLIENT_OBJECT,
 } = RelayConcreteNode;
 const {getStorageKey, getModuleOperationKey} = RelayStoreUtils;
@@ -236,6 +238,9 @@ class RelayReferenceMarker {
         case RELAY_RESOLVER:
           this._traverseResolverField(selection, record);
           break;
+        case RELAY_LIVE_RESOLVER:
+          this._traverseResolverField(selection, record);
+          break;
         case CLIENT_EDGE_TO_CLIENT_OBJECT:
           this._traverseClientEdgeToClientObject(selection, record);
           break;
@@ -303,7 +308,7 @@ class RelayReferenceMarker {
   }
 
   _traverseResolverField(
-    field: NormalizationResolverField,
+    field: NormalizationResolverField | NormalizationLiveResolverField,
     record: Record,
   ): ?DataID {
     const storageKey = getStorageKey(field, this._variables);

package/store/RelayResponseNormalizer.js.flow

@@ -17,6 +17,7 @@ import type {
   NormalizationActorChange,
   NormalizationDefer,
   NormalizationLinkedField,
+  NormalizationLiveResolverField,
   NormalizationModuleImport,
   NormalizationNode,
   NormalizationResolverField,
@@ -50,6 +51,7 @@ const {
   LINKED_FIELD,
   LINKED_HANDLE,
   MODULE_IMPORT,
+  RELAY_LIVE_RESOLVER,
   RELAY_RESOLVER,
   SCALAR_FIELD,
   SCALAR_HANDLE,
@@ -327,6 +329,9 @@ class RelayResponseNormalizer {
         case RELAY_RESOLVER:
           this._normalizeResolver(selection, record, data);
           break;
+        case RELAY_LIVE_RESOLVER:
+          this._normalizeResolver(selection, record, data);
+          break;
         case CLIENT_EDGE_TO_CLIENT_OBJECT:
           this._normalizeResolver(selection.backingField, record, data);
           break;
@@ -342,7 +347,7 @@ class RelayResponseNormalizer {
   }
 
   _normalizeResolver(
-    resolver: NormalizationResolverField,
+    resolver: NormalizationResolverField | NormalizationLiveResolverField,
     record: Record,
     data: PayloadData,
   ) {

package/store/RelayStoreTypes.js.flow

@@ -714,6 +714,11 @@ export type LiveResolverBatchEndLogEvent = {
   +name: 'liveresolver.batch.end',
 };
 
+export type UseFragmentSubscriptionMissedUpdates = {
+  +name: 'useFragment.subscription.missedUpdates',
+  +hasDataChanges: boolean,
+};
+
 export type LogEvent =
   | SuspenseFragmentLogEvent
   | SuspenseQueryLogEvent
@@ -741,7 +746,8 @@ export type LogEvent =
   | StoreNotifySubscriptionLogEvent
   | EntrypointRootConsumeLogEvent
   | LiveResolverBatchStartLogEvent
-  | LiveResolverBatchEndLogEvent;
+  | LiveResolverBatchEndLogEvent
+  | UseFragmentSubscriptionMissedUpdates;
 
 export type LogFunction = LogEvent => void;
 export type LogRequestInfoFunction = mixed => void;

package/store/RelayStoreUtils.js.flow

@@ -31,7 +31,10 @@ const RelayConcreteNode = require('../util/RelayConcreteNode');
 const stableCopy = require('../util/stableCopy');
 const invariant = require('invariant');
 
-export type Arguments = {+[string]: mixed};
+export type Arguments = {
+  +FRAGMENT_POINTER_IS_WITHIN_UNMATCHED_TYPE_REFINEMENT?: boolean,
+  +[string]: mixed,
+};
 
 const {VARIABLE, LITERAL, OBJECT_VALUE, LIST_VALUE} = RelayConcreteNode;
 
@@ -68,13 +71,24 @@ function getArgumentValue(
  * names. Guaranteed to return a result with stable ordered nested values.
  */
 function getArgumentValues(
-  args: $ReadOnlyArray<NormalizationArgument | ReaderArgument>,
+  args?: ?$ReadOnlyArray<NormalizationArgument | ReaderArgument>,
   variables: Variables,
+  isWithinUnmatchedTypeRefinement?: boolean,
 ): Arguments {
-  const values: {[string]: mixed} = {};
-  args.forEach(arg => {
-    values[arg.name] = getArgumentValue(arg, variables);
-  });
+  const values: {
+    FRAGMENT_POINTER_IS_WITHIN_UNMATCHED_TYPE_REFINEMENT?: boolean,
+    [string]: mixed,
+  } = {};
+  if (isWithinUnmatchedTypeRefinement == true) {
+    values[
+      RelayStoreUtils.FRAGMENT_POINTER_IS_WITHIN_UNMATCHED_TYPE_REFINEMENT
+    ] = true;
+  }
+  if (args) {
+    args.forEach(arg => {
+      values[arg.name] = getArgumentValue(arg, variables);
+    });
+  }
   return values;
 }
 
@@ -239,6 +253,8 @@ const RelayStoreUtils = {
   CLIENT_EDGE_TRAVERSAL_PATH: '__clientEdgeTraversalPath',
   FRAGMENTS_KEY: '__fragments',
   FRAGMENT_OWNER_KEY: '__fragmentOwner',
+  FRAGMENT_POINTER_IS_WITHIN_UNMATCHED_TYPE_REFINEMENT:
+    '$isWithinUnmatchedTypeRefinement',
   FRAGMENT_PROP_NAME_KEY: '__fragmentPropName',
   MODULE_COMPONENT_KEY: '__module_component', // alias returned by Reader
   ID_KEY: '__id',
@@ -248,7 +264,6 @@ const RelayStoreUtils = {
   ROOT_TYPE: '__Root',
   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_SNAPSHOT_KEY: '__resolverSnapshot',

package/store/experimental-live-resolvers/resolverDataInjector.js.flow

@@ -6,6 +6,7 @@
  *
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';

package/store/experimental-live-resolvers/weakObjectWrapper.js.flow

@@ -6,6 +6,7 @@
  *
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';

package/util/NormalizationNode.js.flow

@@ -11,6 +11,7 @@
 
 'use strict';
 
+import type {ResolverModule} from './ReaderNode';
 import type {ConcreteRequest} from './RelayConcreteNode';
 import type {JSResourceReference} from 'JSResourceReference';
 
@@ -78,6 +79,7 @@ export type NormalizationClientExtension = {
 
 export type NormalizationField =
   | NormalizationResolverField
+  | NormalizationLiveResolverField
   | NormalizationScalarField
   | NormalizationLinkedField;
 
@@ -167,15 +169,26 @@ export type NormalizationResolverField = {
   +kind: 'RelayResolver',
   +name: string,
   +args: ?$ReadOnlyArray<NormalizationArgument>,
-  +fragment: ?NormalizationInlineFragment,
+  +fragment?: ?NormalizationInlineFragment,
   +storageKey: ?string,
   +isOutputType: boolean,
+  +resolverModule?: ResolverModule,
+};
+
+export type NormalizationLiveResolverField = {
+  +kind: 'RelayLiveResolver',
+  +name: string,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +fragment?: ?NormalizationInlineFragment,
+  +storageKey: ?string,
+  +isOutputType: boolean,
+  +resolverModule?: ResolverModule,
 };
 
 export type NormalizationClientEdgeToClientObject = {
   +kind: 'ClientEdgeToClientObject',
   +linkedField: NormalizationLinkedField,
-  +backingField: NormalizationResolverField,
+  +backingField: NormalizationResolverField | NormalizationLiveResolverField,
 };
 
 export type NormalizationClientComponent = {

package/util/ReaderNode.js.flow

@@ -241,7 +241,7 @@ export type ReaderRequiredField = {
 
 type ResolverFunction = (...args: Array<any>) => mixed; // flowlint-line unclear-type:off
 // With ES6 imports, a resolver function might be exported under the `default` key.
-type ResolverModule = ResolverFunction | {default: ResolverFunction};
+export type ResolverModule = ResolverFunction | {default: ResolverFunction};
 
 export type ResolverNormalizationInfo = {
   +concreteType: string | null,

package/util/createPayloadFor3DField.js.flow

@@ -25,6 +25,7 @@ export opaque type Local3DPayload<
   +Response: {...},
 > = Response;
 
+// $FlowFixMe[unsupported-variance-annotation]
 function createPayloadFor3DField<+DocumentName: string, +Response: {...}>(
   name: DocumentName,
   operation: JSResourceReference<NormalizationSplitOperation>,

package/util/recycleNodesInto.js.flow

@@ -11,9 +11,6 @@
 
 'use strict';
 
-const hasWeakSetDefined = typeof WeakSet !== 'undefined';
-const hasWeakMapDefined = typeof WeakMap !== 'undefined';
-
 /**
  * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.
  */
@@ -21,17 +18,11 @@ function recycleNodesInto<T>(prevData: T, nextData: T): T {
   if (
     prevData === nextData ||
     typeof prevData !== 'object' ||
-    prevData instanceof Set ||
-    prevData instanceof Map ||
-    (hasWeakSetDefined && prevData instanceof WeakSet) ||
-    (hasWeakMapDefined && prevData instanceof WeakMap) ||
     !prevData ||
+    (prevData.constructor !== Object && !Array.isArray(prevData)) ||
     typeof nextData !== 'object' ||
-    nextData instanceof Set ||
-    nextData instanceof Map ||
-    (hasWeakSetDefined && nextData instanceof WeakSet) ||
-    (hasWeakMapDefined && nextData instanceof WeakMap) ||
-    !nextData
+    !nextData ||
+    (nextData.constructor !== Object && !Array.isArray(nextData))
   ) {
     return nextData;
   }
@@ -45,14 +36,8 @@ function recycleNodesInto<T>(prevData: T, nextData: T): T {
       nextArray.reduce((wasEqual, nextItem, ii) => {
         const prevValue = prevArray[ii];
         const nextValue = recycleNodesInto(prevValue, nextItem);
-        if (nextValue !== nextArray[ii]) {
-          if (__DEV__) {
-            if (!Object.isFrozen(nextArray)) {
-              nextArray[ii] = nextValue;
-            }
-          } else {
-            nextArray[ii] = nextValue;
-          }
+        if (nextValue !== nextArray[ii] && !Object.isFrozen(nextArray)) {
+          nextArray[ii] = nextValue;
         }
         return wasEqual && nextValue === prevArray[ii];
       }, true) && prevArray.length === nextArray.length;
@@ -66,16 +51,9 @@ function recycleNodesInto<T>(prevData: T, nextData: T): T {
       nextKeys.reduce((wasEqual, key) => {
         const prevValue = prevObject[key];
         const nextValue = recycleNodesInto(prevValue, nextObject[key]);
-        if (nextValue !== nextObject[key]) {
-          if (__DEV__) {
-            if (!Object.isFrozen(nextObject)) {
-              // $FlowFixMe[cannot-write]
-              nextObject[key] = nextValue;
-            }
-          } else {
-            // $FlowFixMe[cannot-write]
-            nextObject[key] = nextValue;
-          }
+        if (nextValue !== nextObject[key] && !Object.isFrozen(nextObject)) {
+          // $FlowFixMe[cannot-write]
+          nextObject[key] = nextValue;
         }
         return wasEqual && nextValue === prevObject[key];
       }, true) && prevKeys.length === nextKeys.length;