relay-runtime 18.2.0 → 20.0.0

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.2.0",
+  "version": "20.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

@@ -73,6 +73,7 @@ function check(
   getDataID: GetDataID,
   shouldProcessClientComponents: ?boolean,
   log: ?LogFunction,
+  useExecTimeResolvers: ?boolean,
 ): Availability {
   if (log != null) {
     log({
@@ -90,6 +91,8 @@ function check(
     operationLoader,
     getDataID,
     shouldProcessClientComponents,
+    log,
+    useExecTimeResolvers,
   );
   const result = checker.check(node, dataID);
   if (log != null) {
@@ -112,6 +115,7 @@ class DataChecker {
   _recordSourceProxy: RelayRecordSourceProxy;
   _recordWasMissing: boolean;
   _source: RecordSource;
+  _useExecTimeResolvers: boolean;
   _variables: Variables;
   _shouldProcessClientComponents: ?boolean;
   +_getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource;
@@ -123,6 +127,7 @@ class DataChecker {
     ActorIdentifier,
     [RelayRecordSourceMutator, RelayRecordSourceProxy],
   >;
+  _log: ?LogFunction;
 
   constructor(
     getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource,
@@ -135,6 +140,8 @@ class DataChecker {
     operationLoader: ?OperationLoader,
     getDataID: GetDataID,
     shouldProcessClientComponents: ?boolean,
+    log: ?LogFunction,
+    useExecTimeResolvers: ?boolean,
   ) {
     this._getSourceForActor = getSourceForActor;
     this._getTargetForActor = getTargetForActor;
@@ -144,6 +151,7 @@ class DataChecker {
     const [mutator, recordSourceProxy] = this._getMutatorAndRecordProxyForActor(
       defaultActorIdentifier,
     );
+    this._useExecTimeResolvers = useExecTimeResolvers ?? false;
     this._mostRecentlyInvalidatedAt = null;
     this._handlers = handlers;
     this._mutator = mutator;
@@ -152,6 +160,7 @@ class DataChecker {
     this._recordWasMissing = false;
     this._variables = variables;
     this._shouldProcessClientComponents = shouldProcessClientComponents;
+    this._log = log;
   }
 
   _getMutatorAndRecordProxyForActor(
@@ -170,6 +179,7 @@ class DataChecker {
         this._getDataID,
         undefined,
         this._handlers,
+        this._log,
       );
       tuple = [mutator, recordSourceProxy];
       this._mutatorRecordSourceProxyCache.set(actorIdentifier, tuple);
@@ -449,13 +459,15 @@ class DataChecker {
           this._traverseSelections(selection.fragment.selections, dataID);
           break;
         case 'RelayResolver':
-          this._checkResolver(selection, dataID);
-          break;
         case 'RelayLiveResolver':
-          this._checkResolver(selection, dataID);
+          if (!this._useExecTimeResolvers) {
+            this._checkResolver(selection, dataID);
+          }
           break;
         case 'ClientEdgeToClientObject':
-          this._checkResolver(selection.backingField, dataID);
+          if (!this._useExecTimeResolvers) {
+            this._checkResolver(selection.backingField, dataID);
+          }
           break;
         default:
           (selection: empty);

package/store/OperationExecutor.js.flow

@@ -138,6 +138,7 @@ class Executor<TMutation: MutationParameters> {
   _operationTracker: OperationTracker;
   _operationUpdateEpochs: Map<string, number>;
   _optimisticUpdates: null | Array<OptimisticUpdate<TMutation>>;
+  _useExecTimeResolvers: boolean;
   _pendingModulePayloadsCount: number;
   +_getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
   _shouldProcessClientComponents: ?boolean;
@@ -158,6 +159,7 @@ class Executor<TMutation: MutationParameters> {
   +_isSubscriptionOperation: boolean;
   +_seenActors: Set<ActorIdentifier>;
   _normalizeResponse: NormalizeResponseFunction;
+  _execTimeResolverResponseComplete: boolean;
 
   constructor({
     actorIdentifier,
@@ -193,6 +195,12 @@ class Executor<TMutation: MutationParameters> {
     this._operationTracker = operationTracker;
     this._operationUpdateEpochs = new Map();
     this._optimisticUpdates = null;
+    this._useExecTimeResolvers =
+      this._operation.request.node.operation.use_exec_time_resolvers ??
+      this._operation.request.node.operation.exec_time_resolvers_enabled_provider?.get() ===
+        true ??
+      false;
+    this._execTimeResolverResponseComplete = false;
     this._pendingModulePayloadsCount = 0;
     this._getPublishQueue = getPublishQueue;
     this._scheduler = scheduler;
@@ -245,6 +253,12 @@ class Executor<TMutation: MutationParameters> {
           cacheConfig: this._operation.request.cacheConfig ?? {},
         });
       },
+      unsubscribe: () => {
+        this._log({
+          name: 'execute.unsubscribe',
+          executeId: this._executeId,
+        });
+      },
     });
 
     if (
@@ -293,7 +307,7 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _updateActiveState(): void {
-    let activeState;
+    let activeState: ActiveState;
     switch (this._state) {
       case 'started': {
         activeState = 'active';
@@ -309,7 +323,11 @@ class Executor<TMutation: MutationParameters> {
       }
       case 'loading_final': {
         activeState =
-          this._pendingModulePayloadsCount > 0 ? 'active' : 'inactive';
+          this._pendingModulePayloadsCount > 0 ||
+          (this._useExecTimeResolvers &&
+            !this._execTimeResolverResponseComplete)
+            ? 'active'
+            : 'inactive';
         break;
       }
       default:
@@ -510,9 +528,10 @@ class Executor<TMutation: MutationParameters> {
       return;
     }
 
-    const [nonIncrementalResponses, incrementalResponses] =
+    const [nonIncrementalResponses, incrementalResponses, normalizedResponses] =
       partitionGraphQLResponses(responsesWithData);
     const hasNonIncrementalResponses = nonIncrementalResponses.length > 0;
+    const hasNormalizedResponses = normalizedResponses.length > 0;
 
     // In theory this doesn't preserve the ordering of the batch.
     // The idea is that a batch is always:
@@ -547,6 +566,37 @@ class Executor<TMutation: MutationParameters> {
       this._processPayloadFollowups(payloadFollowups);
     }
 
+    if (hasNormalizedResponses) {
+      const payloadFollowups = [];
+      for (let i = 0; i < normalizedResponses.length; i++) {
+        const response = normalizedResponses[i];
+        const source = new RelayRecordSource(
+          response.data as $FlowExpectedError,
+        );
+        const isFinal = response.extensions?.is_final === true;
+        const payload: RelayResponsePayload = {
+          errors: [],
+          fieldPayloads: [],
+          followupPayloads: [],
+          incrementalPlaceholders: [],
+          isFinal,
+          source,
+        };
+        this._getPublishQueueAndSaveActor().commitPayload(
+          this._operation,
+          payload,
+          this._updater,
+        );
+        payloadFollowups.push(payload);
+        this._execTimeResolverResponseComplete = isFinal;
+        if (isFinal) {
+          // Need to update the active state to mark the query as inactive,
+          // incase server payloads have completed
+          this._updateActiveState();
+        }
+      }
+    }
+
     if (incrementalResponses.length > 0) {
       const payloadFollowups =
         this._processIncrementalResponses(incrementalResponses);
@@ -572,7 +622,9 @@ class Executor<TMutation: MutationParameters> {
     // the publish queue here, which will later be passed to the store (via
     // notify) to indicate that this operation caused the store to update
     const updatedOwners = this._runPublishQueue(
-      hasNonIncrementalResponses ? this._operation : undefined,
+      hasNonIncrementalResponses || hasNormalizedResponses
+        ? this._operation
+        : undefined,
     );
 
     if (hasNonIncrementalResponses) {
@@ -606,10 +658,12 @@ class Executor<TMutation: MutationParameters> {
         {
           actorIdentifier: this._actorIdentifier,
           getDataID: this._getDataID,
+          log: this._log,
           path: [],
           shouldProcessClientComponents: this._shouldProcessClientComponents,
           treatMissingFieldsAsNull,
         },
+        this._useExecTimeResolvers,
       );
       validateOptimisticResponsePayload(payload);
       optimisticUpdates.push({
@@ -708,17 +762,26 @@ class Executor<TMutation: MutationParameters> {
       followupPayload.dataID,
       variables,
     );
+    const nextResponse: GraphQLResponseWithData = {
+      data: followupPayload.data,
+      // `is_final` flag needs to be set for processing nested defer and 3D
+      // when the server doesn't support streaming
+      extensions:
+        this._state === 'loading_final' ? {is_final: true} : undefined,
+    };
     return this._normalizeResponse(
-      {data: followupPayload.data},
+      nextResponse,
       selector,
       followupPayload.typeName,
       {
         actorIdentifier: this._actorIdentifier,
         getDataID: this._getDataID,
+        log: this._log,
         path: followupPayload.path,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
       },
+      this._useExecTimeResolvers,
     );
   }
 
@@ -797,10 +860,12 @@ class Executor<TMutation: MutationParameters> {
         {
           actorIdentifier: this._actorIdentifier,
           getDataID: this._getDataID,
+          log: this._log,
           path: [],
           treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           shouldProcessClientComponents: this._shouldProcessClientComponents,
         },
+        this._useExecTimeResolvers,
       );
       this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
@@ -875,7 +940,8 @@ class Executor<TMutation: MutationParameters> {
                   placeholder.label,
                   placeholder.path,
                   placeholder,
-                  {data: placeholder.data},
+                  // `is_final` flag needs to be set for processing nested defer payloads
+                  {data: placeholder.data, extensions: {is_final: true}},
                 ),
               );
             }
@@ -889,7 +955,14 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _maybeCompleteSubscriptionOperationTracking() {
-    if (!this._isSubscriptionOperation) {
+    if (
+      !this._isSubscriptionOperation &&
+      !(
+        this._useExecTimeResolvers &&
+        this._execTimeResolverResponseComplete &&
+        this._state === 'loading_final'
+      )
+    ) {
       return;
     }
     if (
@@ -1253,10 +1326,12 @@ class Executor<TMutation: MutationParameters> {
       {
         actorIdentifier: this._actorIdentifier,
         getDataID: this._getDataID,
+        log: this._log,
         path: placeholder.path,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
       },
+      this._useExecTimeResolvers,
     );
     this._getPublishQueueAndSaveActor().commitPayload(
       this._operation,
@@ -1477,13 +1552,20 @@ class Executor<TMutation: MutationParameters> {
       record: nextParentRecord,
       fieldPayloads,
     });
-    const relayPayload = this._normalizeResponse(response, selector, typeName, {
-      actorIdentifier: this._actorIdentifier,
-      getDataID: this._getDataID,
-      path: [...normalizationPath, responseKey, String(itemIndex)],
-      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-      shouldProcessClientComponents: this._shouldProcessClientComponents,
-    });
+    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,
+      },
+      this._useExecTimeResolvers,
+    );
     return {
       fieldPayloads,
       itemID,
@@ -1586,9 +1668,11 @@ function partitionGraphQLResponses(
 ): [
   $ReadOnlyArray<GraphQLResponseWithData>,
   $ReadOnlyArray<IncrementalGraphQLResponse>,
+  $ReadOnlyArray<GraphQLResponseWithData>,
 ] {
   const nonIncrementalResponses: Array<GraphQLResponseWithData> = [];
   const incrementalResponses: Array<IncrementalGraphQLResponse> = [];
+  const normalizedResponses: Array<GraphQLResponseWithData> = [];
   responses.forEach(response => {
     if (response.path != null || response.label != null) {
       const {label, path} = response;
@@ -1606,11 +1690,13 @@ function partitionGraphQLResponses(
         path,
         response,
       });
+    } else if (response.extensions?.is_normalized === true) {
+      normalizedResponses.push(response);
     } else {
       nonIncrementalResponses.push(response);
     }
   });
-  return [nonIncrementalResponses, incrementalResponses];
+  return [nonIncrementalResponses, incrementalResponses, normalizedResponses];
 }
 
 function stableStringify(value: mixed): string {

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;
   }

package/store/RelayModernEnvironment.js.flow

@@ -58,6 +58,7 @@ const defaultGetDataID = require('./defaultGetDataID');
 const defaultRelayFieldLogger = require('./defaultRelayFieldLogger');
 const normalizeResponse = require('./normalizeResponse');
 const OperationExecutor = require('./OperationExecutor');
+const RelayModernStore = require('./RelayModernStore');
 const RelayPublishQueue = require('./RelayPublishQueue');
 const RelayRecordSource = require('./RelayRecordSource');
 const invariant = require('invariant');
@@ -71,7 +72,7 @@ export type EnvironmentConfig = {
   +network: INetwork,
   +normalizeResponse?: ?NormalizeResponseFunction,
   +scheduler?: ?TaskScheduler,
-  +store: Store,
+  +store?: Store,
   +missingFieldHandlers?: ?$ReadOnlyArray<MissingFieldHandler>,
   +operationTracker?: ?OperationTracker,
   +getDataID?: ?GetDataID,
@@ -118,6 +119,15 @@ class RelayModernEnvironment implements IEnvironment {
         );
       }
     }
+    const store =
+      config.store ??
+      new RelayModernStore(new RelayRecordSource(), {
+        log: config.log,
+        operationLoader: config.operationLoader,
+        getDataID: config.getDataID,
+        shouldProcessClientComponents: config.shouldProcessClientComponents,
+      });
+
     this.__log = config.log ?? emptyFunction;
     this.relayFieldLogger = config.relayFieldLogger ?? defaultRelayFieldLogger;
     this._defaultRenderPolicy =
@@ -128,13 +138,14 @@ class RelayModernEnvironment implements IEnvironment {
     this._getDataID = config.getDataID ?? defaultGetDataID;
     this._missingFieldHandlers = config.missingFieldHandlers ?? [];
     this._publishQueue = new RelayPublishQueue(
-      config.store,
+      store,
       config.handlerProvider ?? RelayDefaultHandlerProvider,
       this._getDataID,
       this._missingFieldHandlers,
+      this.__log,
     );
     this._scheduler = config.scheduler ?? null;
-    this._store = config.store;
+    this._store = store;
     this.options = config.options;
     this._isServer = config.isServer ?? false;
     this._normalizeResponse = config.normalizeResponse ?? normalizeResponse;
@@ -327,13 +338,18 @@ class RelayModernEnvironment implements IEnvironment {
     operation: OperationDescriptor,
   }): RelayObservable<GraphQLResponse> {
     return this._execute({
-      createSource: () =>
-        this.getNetwork().execute(
+      createSource: () => {
+        return this.getNetwork().execute(
           operation.request.node.params,
           operation.request.variables,
           operation.request.cacheConfig || {},
           null,
-        ),
+          undefined,
+          undefined,
+          undefined,
+          () => this.check(operation),
+        );
+      },
       isClientPayload: false,
       operation,
       optimisticConfig: null,

package/store/RelayModernFragmentSpecResolver.js.flow

@@ -14,7 +14,7 @@
 import type {ConcreteRequest} from '../util/RelayConcreteNode';
 import type {Disposable, Variables} from '../util/RelayRuntimeTypes';
 import type {
-  ErrorResponseFields,
+  FieldErrors,
   FragmentMap,
   FragmentSpecResolver,
   FragmentSpecResults,
@@ -228,7 +228,7 @@ class SelectorResolver {
   _data: ?SelectorData;
   _environment: IEnvironment;
   _isMissingData: boolean;
-  _errorResponseFields: ?ErrorResponseFields;
+  _fieldErrors: ?FieldErrors;
   _rootIsQueryRenderer: boolean;
   _selector: SingularReaderSelector;
   _subscription: ?Disposable;
@@ -244,7 +244,7 @@ class SelectorResolver {
     this._callback = callback;
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
-    this._errorResponseFields = snapshot.errorResponseFields;
+    this._fieldErrors = snapshot.fieldErrors;
     this._environment = environment;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
     this._selector = selector;
@@ -325,7 +325,7 @@ class SelectorResolver {
         }
       }
     }
-    handlePotentialSnapshotErrors(this._environment, this._errorResponseFields);
+    handlePotentialSnapshotErrors(this._environment, this._fieldErrors);
     return this._data;
   }
 
@@ -340,7 +340,7 @@ class SelectorResolver {
     const snapshot = this._environment.lookup(selector);
     this._data = recycleNodesInto(this._data, snapshot.data);
     this._isMissingData = snapshot.isMissingData;
-    this._errorResponseFields = snapshot.errorResponseFields;
+    this._fieldErrors = snapshot.fieldErrors;
     this._selector = selector;
     this._subscription = this._environment.subscribe(snapshot, this._onChange);
   }
@@ -376,7 +376,7 @@ class SelectorResolver {
   _onChange = (snapshot: Snapshot): void => {
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
-    this._errorResponseFields = snapshot.errorResponseFields;
+    this._fieldErrors = snapshot.fieldErrors;
     this._callback();
   };
 }

package/store/RelayModernSelector.js.flow

@@ -340,6 +340,7 @@ function getVariablesFromObject(
       const fragment = fragments[key];
       const item = object[key];
       const itemVariables = getVariablesFromFragment(fragment, item);
+      // $FlowFixMe[unsafe-object-assign]
       Object.assign(variables, itemVariables);
     }
   }
@@ -397,6 +398,7 @@ function getVariablesFromPluralFragment(
     if (value != null) {
       const itemVariables = getVariablesFromSingularFragment(fragment, value);
       if (itemVariables != null) {
+        // $FlowFixMe[unsafe-object-assign]
         Object.assign(variables, itemVariables);
       }
     }