relay-runtime 13.0.0-rc.2 → 13.0.3

package/store/RelayConcreteVariables.js.flow

@@ -18,6 +18,7 @@ import type {
   NormalizationOperation,
 } from '../util/NormalizationNode';
 import type {ReaderFragment} from '../util/ReaderNode';
+import type {ProvidedVariablesType} from '../util/RelayConcreteNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
 const {getArgumentValues} = require('./RelayStoreUtils');
@@ -76,12 +77,15 @@ function getFragmentVariables(
 
 /**
  * Determines the variables that are in scope for a given operation given values
- * for some/all of its arguments. Extraneous input variables are filtered from
- * the output, and missing variables are set to default values (if given in the
+ * for some/all of its arguments.
+ * - extraneous input variables are filtered from the output
+ * - missing variables are set to default values (if given in the
  * operation's definition).
+ * - variables with provider modules are added
  */
 function getOperationVariables(
   operation: NormalizationOperation,
+  providedVariables: ?ProvidedVariablesType,
   variables: Variables,
 ): Variables {
   const operationVariables = {};
@@ -92,6 +96,12 @@ function getOperationVariables(
     }
     operationVariables[def.name] = value;
   });
+
+  if (providedVariables != null) {
+    Object.keys(providedVariables).forEach((varName: string) => {
+      operationVariables[varName] = providedVariables[varName].get();
+    });
+  }
   return operationVariables;
 }
 

package/store/RelayExperimentalGraphResponseTransform.js.flow

@@ -31,7 +31,9 @@ const {
   FRAGMENT_SPREAD,
   INLINE_FRAGMENT,
   LINKED_FIELD,
+  LINKED_HANDLE,
   SCALAR_FIELD,
+  SCALAR_HANDLE,
 } = require('../util/RelayConcreteNode');
 const {getLocalVariables} = require('./RelayConcreteVariables');
 const {createNormalizationSelector} = require('./RelayModernSelector');
@@ -91,6 +93,10 @@ export type GraphModeChunk = DataChunk | CompleteChunk;
 
 export type GraphModeResponse = Iterable<GraphModeChunk>;
 
+export type TransformMetadata = {
+  duplicateFieldsAvoided: number,
+};
+
 /**
  * Converts a JSON response (and Normalization AST) into a stream of GraphMode chunks
  *
@@ -128,7 +134,20 @@ export function normalizeResponse(
   return normalizer.normalizeResponse(node, dataID, response);
 }
 
-class GraphModeNormalizer {
+export function normalizeResponseWithMetadata(
+  response: PayloadData,
+  selector: NormalizationSelector,
+  options: NormalizationOptions,
+): [Array<GraphModeChunk>, TransformMetadata] {
+  const {node, variables, dataID} = selector;
+  const normalizer = new GraphModeNormalizer(variables, options);
+  const chunks = Array.from(
+    normalizer.normalizeResponse(node, dataID, response),
+  );
+  return [chunks, {duplicateFieldsAvoided: normalizer.duplicateFieldsAvoided}];
+}
+
+export class GraphModeNormalizer {
   _cacheKeyToStreamID: Map<string, number>;
   _sentFields: Map<string, Set<string>>;
   _getDataId: GetDataID;
@@ -138,6 +157,7 @@ class GraphModeNormalizer {
   _path: Array<string>;
   _incrementalPlaceholders: Array<IncrementalDataPlaceholder>;
   _actorIdentifier: ?ActorIdentifier;
+  duplicateFieldsAvoided: number;
   constructor(variables: Variables, options: NormalizationOptions) {
     this._actorIdentifier = options.actorIdentifier;
     this._path = options.path ? [...options.path] : [];
@@ -146,6 +166,7 @@ class GraphModeNormalizer {
     this._sentFields = new Map();
     this._nextStreamID = 0;
     this._variables = variables;
+    this.duplicateFieldsAvoided = 0;
   }
 
   _getStreamID() {
@@ -266,6 +287,7 @@ class GraphModeNormalizer {
           // TODO: We could also opt to confirm that this matches the previously
           // seen value.
           if (sentFields.has(storageKey)) {
+            this.duplicateFieldsAvoided++;
             break;
           }
 
@@ -281,6 +303,7 @@ class GraphModeNormalizer {
           // TODO: We could also opt to confirm that this matches the previously
           // seen value.
           if (sentFields.has(storageKey)) {
+            this.duplicateFieldsAvoided++;
             break;
           }
           const fieldData = ((data[responseKey]: any): ChunkField);
@@ -374,6 +397,17 @@ class GraphModeNormalizer {
           // Since we are only expecting to handle server responses, we can skip
           // over client extensions.
           break;
+        case SCALAR_HANDLE:
+        case LINKED_HANDLE:
+          // Handles allow us to record information that will be needed to
+          // perform additional process when we insert data into the store. For
+          // example, connection edges need to be prepended/appended to the
+          // pre-existing values.
+          //
+          // GraphMode will eventually need some replacement for this, but it is
+          // not nessesary in order to measure things like response size, so we
+          // can ignore these for now.
+          break;
         default:
           throw new Error(`Unexpected selection type: ${selection.kind}`);
       }

package/store/RelayModernOperationDescriptor.js.flow

@@ -44,7 +44,11 @@ function createOperationDescriptor<TQuery: OperationType>(
   dataID?: DataID = ROOT_ID,
 ): OperationDescriptor {
   const operation = request.operation;
-  const operationVariables = getOperationVariables(operation, variables);
+  const operationVariables = getOperationVariables(
+    operation,
+    request.params.providedVariables,
+    variables,
+  );
   const requestDescriptor = createRequestDescriptor(
     request,
     operationVariables,

package/store/RelayModernStore.js.flow

@@ -12,7 +12,6 @@
 
 'use strict';
 
-import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {DataID, Disposable} from '../util/RelayRuntimeTypes';
 import type {Availability} from './DataChecker';
 import type {GetDataID} from './RelayResponseNormalizer';

package/store/RelayPublishQueue.js.flow

@@ -57,8 +57,15 @@ type PendingUpdater = {|
   +updater: StoreUpdater,
 |};
 
+const _global: typeof global | $FlowFixMe =
+  typeof global !== 'undefined'
+    ? global
+    : typeof window !== 'undefined'
+    ? window
+    : undefined;
+
 const applyWithGuard =
-  global?.ErrorUtils?.applyWithGuard ??
+  _global?.ErrorUtils?.applyWithGuard ??
   ((callback, context, args, onError, name) => callback.apply(context, args));
 
 /**

package/store/RelayReader.js.flow

@@ -109,6 +109,7 @@ class RelayReader {
   _selector: SingularReaderSelector;
   _variables: Variables;
   _resolverCache: ResolverCache;
+  _fragmentName: string;
 
   constructor(
     recordSource: RecordSource,
@@ -130,6 +131,7 @@ class RelayReader {
     this._selector = selector;
     this._variables = selector.variables;
     this._resolverCache = resolverCache;
+    this._fragmentName = selector.node.name;
   }
 
   read(): Snapshot {
@@ -267,7 +269,7 @@ class RelayReader {
       // encounter is likely to be the root cause of the error.
       return;
     }
-    const owner = this._selector.node.name;
+    const owner = this._fragmentName;
 
     switch (action) {
       case 'THROW':
@@ -275,9 +277,19 @@ class RelayReader {
         return;
       case 'LOG':
         if (this._missingRequiredFields == null) {
-          this._missingRequiredFields = {action, fields: []};
+          this._missingRequiredFields = {
+            action,
+            fields: [{path: fieldPath, owner}],
+          };
+        } else {
+          this._missingRequiredFields = {
+            action,
+            fields: [
+              ...this._missingRequiredFields.fields,
+              {path: fieldPath, owner},
+            ],
+          };
         }
-        this._missingRequiredFields.fields.push({path: fieldPath, owner});
         return;
       default:
         (action: empty);
@@ -483,8 +495,7 @@ class RelayReader {
         if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
           throw new Error('Relay Resolver fields are not yet supported.');
         }
-        this._readResolverField(selection.field, record, data);
-        break;
+        return this._readResolverField(selection.field, record, data);
       default:
         (selection.field.kind: empty);
         invariant(
@@ -499,7 +510,7 @@ class RelayReader {
     field: ReaderRelayResolver,
     record: Record,
     data: SelectorData,
-  ): void {
+  ): mixed {
     const {resolverModule, fragment} = field;
     const storageKey = getStorageKey(field, this._variables);
     const resolverID = ClientID.generateClientID(
@@ -512,6 +523,8 @@ class RelayReader {
     // inputs have changed since a previous evaluation:
     let fragmentValue;
     let fragmentReaderSelector;
+    let fragmentMissingRequiredFields: ?MissingRequiredFields;
+    let previousMissingRequriedFields: ?MissingRequiredFields;
     const fragmentSeenRecordIDs = new Set();
 
     const getDataForResolverFragment = singularReaderSelector => {
@@ -526,11 +539,14 @@ class RelayReader {
       try {
         this._seenRecords = fragmentSeenRecordIDs;
         const resolverFragmentData = {};
+        previousMissingRequriedFields = this._missingRequiredFields;
+        this._missingRequiredFields = null;
         this._createInlineDataOrResolverFragmentPointer(
           singularReaderSelector.node,
           record,
           resolverFragmentData,
         );
+        fragmentMissingRequiredFields = this._missingRequiredFields;
         fragmentValue = resolverFragmentData[FRAGMENTS_KEY]?.[fragment.name];
         invariant(
           typeof fragmentValue === 'object' && fragmentValue !== null,
@@ -539,42 +555,50 @@ class RelayReader {
         return fragmentValue;
       } finally {
         this._seenRecords = existingSeenRecords;
+        this._missingRequiredFields = previousMissingRequriedFields;
       }
     };
     const resolverContext = {getDataForResolverFragment};
 
-    const [result, seenRecord] = this._resolverCache.readFromCacheOrEvaluate(
-      record,
-      field,
-      this._variables,
-      () => {
-        const key = {
-          __id: RelayModernRecord.getDataID(record),
-          __fragmentOwner: this._owner,
-          __fragments: {
-            [fragment.name]: {}, // Arguments to this fragment; not yet supported.
-          },
-        };
-        return withResolverContext(resolverContext, () => {
-          // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
-          const resolverResult = resolverModule(key);
-          return {
-            resolverResult,
-            fragmentValue,
-            resolverID,
-            seenRecordIDs: fragmentSeenRecordIDs,
-            readerSelector: fragmentReaderSelector,
+    const [result, seenRecord, missingRequiredFields] =
+      this._resolverCache.readFromCacheOrEvaluate(
+        record,
+        field,
+        this._variables,
+        () => {
+          const key = {
+            __id: RelayModernRecord.getDataID(record),
+            __fragmentOwner: this._owner,
+            __fragments: {
+              [fragment.name]: {}, // Arguments to this fragment; not yet supported.
+            },
           };
-        });
-      },
-      getDataForResolverFragment,
-    );
+          return withResolverContext(resolverContext, () => {
+            // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+            const resolverResult = resolverModule(key);
+            return {
+              resolverResult,
+              fragmentValue,
+              resolverID,
+              seenRecordIDs: fragmentSeenRecordIDs,
+              readerSelector: fragmentReaderSelector,
+              missingRequiredFields: fragmentMissingRequiredFields,
+            };
+          });
+        },
+        getDataForResolverFragment,
+      );
+
+    if (missingRequiredFields != null) {
+      this._addMissingRequiredFields(missingRequiredFields);
+    }
     if (seenRecord != null) {
       this._seenRecords.add(seenRecord);
     }
 
     const applicationName = field.alias ?? field.name;
     data[applicationName] = result;
+    return result;
   }
 
   _readClientEdge(
@@ -896,14 +920,37 @@ class RelayReader {
       data[ID_KEY] = RelayModernRecord.getDataID(record);
     }
     const inlineData = {};
+    const parentFragmentName = this._fragmentName;
+    this._fragmentName = fragmentSpreadOrFragment.name;
     this._traverseSelections(
       fragmentSpreadOrFragment.selections,
       record,
       inlineData,
     );
+    this._fragmentName = parentFragmentName;
     // $FlowFixMe[cannot-write] - writing into read-only field
     fragmentPointers[fragmentSpreadOrFragment.name] = inlineData;
   }
+
+  _addMissingRequiredFields(additional: MissingRequiredFields) {
+    if (this._missingRequiredFields == null) {
+      this._missingRequiredFields = additional;
+      return;
+    }
+
+    if (this._missingRequiredFields.action === 'THROW') {
+      return;
+    }
+    if (additional.action === 'THROW') {
+      this._missingRequiredFields = additional;
+      return;
+    }
+
+    this._missingRequiredFields = {
+      action: 'LOG',
+      fields: [...this._missingRequiredFields.fields, ...additional.fields],
+    };
+  }
 }
 
 module.exports = {read};

package/store/RelayStoreTypes.js.flow

@@ -117,9 +117,10 @@ type MissingRequiredField = {|
   owner: string,
 |};
 
-export type MissingRequiredFields =
+export type MissingRequiredFields = $ReadOnly<
   | {|action: 'THROW', field: MissingRequiredField|}
-  | {|action: 'LOG', fields: Array<MissingRequiredField>|};
+  | {|action: 'LOG', fields: Array<MissingRequiredField>|},
+>;
 
 export type ClientEdgeTraversalInfo = {|
   +readerClientEdge: ReaderClientEdge,

package/store/RelayStoreUtils.js.flow

@@ -219,6 +219,7 @@ const RelayStoreUtils = {
   RELAY_RESOLVER_INVALIDATION_KEY: '__resolverValueMayBeInvalid',
   RELAY_RESOLVER_INPUTS_KEY: '__resolverInputValues',
   RELAY_RESOLVER_READER_SELECTOR_KEY: '__resolverReaderSelector',
+  RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY: '__resolverMissingRequiredFields',
 
   formatStorageKey,
   getArgumentValue,

package/store/ResolverCache.js.flow

@@ -15,6 +15,7 @@
 import type {ReaderRelayResolver} from '../util/ReaderNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
+  MissingRequiredFields,
   MutableRecordSource,
   Record,
   SingularReaderSelector,
@@ -26,6 +27,7 @@ const RelayModernRecord = require('./RelayModernRecord');
 const {
   RELAY_RESOLVER_INPUTS_KEY,
   RELAY_RESOLVER_INVALIDATION_KEY,
+  RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
   RELAY_RESOLVER_READER_SELECTOR_KEY,
   RELAY_RESOLVER_VALUE_KEY,
   getStorageKey,
@@ -40,6 +42,7 @@ type EvaluationResult<T> = {|
   resolverID: ResolverID,
   seenRecordIDs: Set<DataID>,
   readerSelector: SingularReaderSelector,
+  missingRequiredFields: ?MissingRequiredFields,
 |};
 
 export interface ResolverCache {
@@ -49,7 +52,7 @@ export interface ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: (SingularReaderSelector) => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */];
+  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields];
   invalidateDataIDs(
     updatedDataIDs: Set<DataID>, // Mutated in place
   ): void;
@@ -65,8 +68,9 @@ class NoopResolverCache implements ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: SingularReaderSelector => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */] {
-    return [evaluate().resolverResult, undefined];
+  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields] {
+    const {resolverResult, missingRequiredFields} = evaluate();
+    return [resolverResult, undefined, missingRequiredFields];
   }
   invalidateDataIDs(updatedDataIDs: Set<DataID>): void {}
 }
@@ -102,7 +106,7 @@ class RecordResolverCache implements ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: SingularReaderSelector => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */] {
+  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields] {
     const recordSource = this._getRecordSource();
     const recordID = RelayModernRecord.getDataID(record);
 
@@ -133,6 +137,11 @@ class RecordResolverCache implements ResolverCache {
         RELAY_RESOLVER_READER_SELECTOR_KEY,
         evaluationResult.readerSelector,
       );
+      RelayModernRecord.setValue(
+        linkedRecord,
+        RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
+        evaluationResult.missingRequiredFields,
+      );
       recordSource.set(linkedID, linkedRecord);
 
       // Link the resolver value record to the resolver field of the record being read:
@@ -155,7 +164,11 @@ class RecordResolverCache implements ResolverCache {
 
     // $FlowFixMe[incompatible-type] - will always be empty
     const answer: T = linkedRecord[RELAY_RESOLVER_VALUE_KEY];
-    return [answer, linkedID];
+
+    const missingRequiredFields: ?MissingRequiredFields =
+      // $FlowFixMe[incompatible-type] - casting mixed
+      linkedRecord[RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY];
+    return [answer, linkedID, missingRequiredFields];
   }
 
   invalidateDataIDs(

package/store/ResolverFragments.js.flow

@@ -42,9 +42,9 @@ function withResolverContext<T>(context: ResolverContext, cb: () => T): T {
 // The declarations ensure that the type of the returned data is:
 //   - non-nullable if the provided ref type is non-nullable
 //   - nullable if the provided ref type is nullable
-//   - array of non-nullable if the privoided ref type is an array of
+//   - array of non-nullable if the provided ref type is an array of
 //     non-nullable refs
-//   - array of nullable if the privoided ref type is an array of nullable refs
+//   - array of nullable if the provided ref type is an array of nullable refs
 
 declare function readFragment<
   TKey: {+$data?: mixed, +$fragmentSpreads: FragmentType, ...},

package/subscription/requestSubscription.js.flow

@@ -30,12 +30,11 @@ const {
   createOperationDescriptor,
 } = require('../store/RelayModernOperationDescriptor');
 const {createReaderSelector} = require('../store/RelayModernSelector');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const warning = require('warning');
 
 export type SubscriptionParameters = {|
   +response: {...},
-  +variables: interface {},
+  +variables: {...},
   +rawResponse?: {...},
 |};
 
@@ -50,18 +49,13 @@ export type GraphQLSubscriptionConfig<T: SubscriptionParameters> = {|
   updater?: ?SelectorStoreUpdater<T['response']>,
 |};
 
-export type DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
-  configs?: Array<DeclarativeMutationConfig>,
-  cacheConfig?: CacheConfig,
-  subscription: GraphQLTaggedNode,
-  variables: Variables,
-  onCompleted?: ?() => void,
-  onError?: ?(error: Error) => void,
-  onNext?: ?(response: ?TSubscriptionPayload) => void,
-  updater?: ?SelectorStoreUpdater<TSubscriptionPayload>,
-|};
+export type DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload: {...}> =
+  GraphQLSubscriptionConfig<{|
+    response: TSubscriptionPayload,
+    variables: Variables,
+  |}>;
 
-function requestSubscription<TSubscriptionPayload>(
+function requestSubscription<TSubscriptionPayload: {...}>(
   environment: IEnvironment,
   config: DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload>,
 ): Disposable {

package/util/NormalizationNode.js.flow

@@ -31,27 +31,27 @@ export type NormalizationHandle =
 
 export type NormalizationLinkedHandle = {|
   +kind: 'LinkedHandle',
-  +alias: ?string,
+  +alias?: ?string,
   +name: string,
-  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
   +handle: string,
   +key: string,
   // NOTE: this property is optional because it's expected to be rarely used
   +dynamicKey?: ?NormalizationArgument,
-  +filters: ?$ReadOnlyArray<string>,
+  +filters?: ?$ReadOnlyArray<string>,
   +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
 |};
 
 export type NormalizationScalarHandle = {|
   +kind: 'ScalarHandle',
-  +alias: ?string,
+  +alias?: ?string,
   +name: string,
-  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
   +handle: string,
   +key: string,
   // NOTE: this property is optional because it's expected to be rarely used
   +dynamicKey?: ?NormalizationArgument,
-  +filters: ?$ReadOnlyArray<string>,
+  +filters?: ?$ReadOnlyArray<string>,
   +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
 |};
 
@@ -82,22 +82,22 @@ export type NormalizationInlineFragment = {|
   +kind: 'InlineFragment',
   +selections: $ReadOnlyArray<NormalizationSelection>,
   +type: string,
-  +abstractKey: ?string,
+  +abstractKey?: ?string,
 |};
 
 export type NormalizationFragmentSpread = {|
   +kind: 'FragmentSpread',
   +fragment: NormalizationSplitOperation,
-  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
 |};
 
 export type NormalizationLinkedField = {|
   +kind: 'LinkedField',
-  +alias: ?string,
+  +alias?: ?string,
   +name: string,
-  +storageKey: ?string,
-  +args: ?$ReadOnlyArray<NormalizationArgument>,
-  +concreteType: ?string,
+  +storageKey?: ?string,
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +concreteType?: ?string,
   +plural: boolean,
   +selections: $ReadOnlyArray<NormalizationSelection>,
 |};
@@ -108,7 +108,7 @@ export type NormalizationActorChange = {|
 |};
 
 export type NormalizationModuleImport = {|
-  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
   +kind: 'ModuleImport',
   +documentName: string,
   +fragmentPropName: string,
@@ -146,10 +146,10 @@ export type NormalizationNode =
 
 export type NormalizationScalarField = {|
   +kind: 'ScalarField',
-  +alias: ?string,
+  +alias?: ?string,
   +name: string,
-  +args: ?$ReadOnlyArray<NormalizationArgument>,
-  +storageKey: ?string,
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +storageKey?: ?string,
 |};
 
 export type NormalizationFlightField = {|