relay-runtime 10.1.3 → 11.0.2

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

@@ -0,0 +1,233 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const ActorSpecificEnvironment = require('./ActorSpecificEnvironment');
+const OperationExecutor = require('../store/OperationExecutor');
+const RelayDefaultHandlerProvider = require('../handlers/RelayDefaultHandlerProvider');
+const RelayModernStore = require('../store/RelayModernStore');
+const RelayObservable = require('../network/RelayObservable');
+const RelayPublishQueue = require('../store/RelayPublishQueue');
+const RelayRecordSource = require('../store/RelayRecordSource');
+
+const defaultGetDataID = require('../store/defaultGetDataID');
+
+import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
+import type {GraphQLResponse, PayloadData} from '../network/RelayNetworkTypes';
+import type {INetwork} from '../network/RelayNetworkTypes';
+import type {ActiveState} from '../store/OperationExecutor';
+import type {GetDataID} from '../store/RelayResponseNormalizer';
+import type {
+  IEnvironment,
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  OperationDescriptor,
+  OperationAvailability,
+  Snapshot,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  StoreUpdater,
+  RequiredFieldLogger,
+  ExecuteMutationConfig,
+  LogFunction,
+} from '../store/RelayStoreTypes';
+import type {Disposable} from '../util/RelayRuntimeTypes';
+import type {ActorIdentifier} from './ActorIdentifier';
+import type {
+  IActorEnvironment,
+  IMultiActorEnvironment,
+} from './MultiActorEnvironmentTypes';
+
+function todo(what: string) {
+  throw new Error(`Not implementd: ${what}`);
+}
+
+export type MultiActorEnvironmentConfig = $ReadOnly<{
+  createNetworkForActor: (actorIdentifier: ActorIdentifier) => INetwork,
+  getDataID?: GetDataID,
+  handlerProvider?: HandlerProvider,
+  logFn: LogFunction,
+  requiredFieldLogger: RequiredFieldLogger,
+  treatMissingFieldsAsNull?: boolean,
+}>;
+
+class MultiActorEnvironment implements IMultiActorEnvironment {
+  +_actorEnvironments: Map<ActorIdentifier, IActorEnvironment>;
+  +_createNetworkForActor: (actorIdentifier: ActorIdentifier) => INetwork;
+  +_getDataID: GetDataID;
+  +_handlerProvider: HandlerProvider;
+  +_logFn: LogFunction;
+  +_operationExecutions: Map<string, ActiveState>;
+  +_requiredFieldLogger: RequiredFieldLogger;
+  +_treatMissingFieldsAsNull: boolean;
+
+  constructor(config: MultiActorEnvironmentConfig) {
+    this._actorEnvironments = new Map();
+    this._createNetworkForActor = config.createNetworkForActor;
+    this._getDataID = config.getDataID ?? defaultGetDataID;
+    this._handlerProvider = config.handlerProvider
+      ? config.handlerProvider
+      : RelayDefaultHandlerProvider;
+    this._logFn = config.logFn;
+    this._operationExecutions = new Map();
+    this._requiredFieldLogger = config.requiredFieldLogger;
+    this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull ?? false;
+  }
+
+  /**
+   * This method will create an actor specfic environment. It will create a new instance
+   * and store it in the internal maps. If will return a memozied version
+   * of the environment if we already created one for actor.
+   */
+  forActor(actorIdentifier: ActorIdentifier): IEnvironment & IActorEnvironment {
+    const environment = this._actorEnvironments.get(actorIdentifier);
+    if (environment == null) {
+      const newEnvironment = new ActorSpecificEnvironment({
+        actorIdentifier,
+        multiActorEnvironment: this,
+        logFn: this._logFn,
+        requiredFieldLogger: this._requiredFieldLogger,
+        store: new RelayModernStore(RelayRecordSource.create()),
+        network: this._createNetworkForActor(actorIdentifier),
+      });
+      this._actorEnvironments.set(actorIdentifier, newEnvironment);
+      return newEnvironment;
+    } else {
+      return environment;
+    }
+  }
+
+  check(
+    actorIdentifier: ActorIdentifier,
+    operation: OperationDescriptor,
+  ): OperationAvailability {
+    return todo('check');
+  }
+
+  subscribe(
+    actorIdentifier: ActorIdentifier,
+    snapshot: Snapshot,
+    callback: (snapshot: Snapshot) => void,
+  ): Disposable {
+    return todo('subscribe');
+  }
+
+  retain(
+    actorIdentifier: ActorIdentifier,
+    operation: OperationDescriptor,
+  ): Disposable {
+    return todo('retain');
+  }
+
+  applyUpdate(
+    actorIdentifier: ActorIdentifier,
+    optimisticUpdate: OptimisticUpdateFunction,
+  ): Disposable {
+    return todo('applyUpdate');
+  }
+
+  applyMutation(
+    actorIdentifier: ActorIdentifier,
+    optimisticConfig: OptimisticResponseConfig,
+  ): Disposable {
+    return todo('applyMutation');
+  }
+
+  commitUpdate(actorIdentifier: ActorIdentifier, updater: StoreUpdater): void {
+    return todo('commitUpdate');
+  }
+
+  commitPayload(
+    actorIdentifier: ActorIdentifier,
+    operationDescriptor: OperationDescriptor,
+    payload: PayloadData,
+  ): void {
+    return todo('commitPayload');
+  }
+
+  lookup(
+    actorIdentifier: ActorIdentifier,
+    selector: SingularReaderSelector,
+  ): Snapshot {
+    return todo('lookup');
+  }
+
+  execute(
+    actorIdentifier: ActorIdentifier,
+    config: {
+      operation: OperationDescriptor,
+      updater?: ?SelectorStoreUpdater,
+    },
+  ): RelayObservable<GraphQLResponse> {
+    const {operation, updater} = config;
+    return RelayObservable.create(sink => {
+      const actorEnvironemnt = this.forActor(actorIdentifier);
+      const source = actorEnvironemnt
+        .getNetwork()
+        .execute(
+          operation.request.node.params,
+          operation.request.variables,
+          operation.request.cacheConfig || {},
+          null,
+        );
+      const executor = OperationExecutor.execute({
+        operation,
+        operationExecutions: this._operationExecutions,
+        operationLoader: null,
+        optimisticConfig: null,
+        publishQueue: new RelayPublishQueue(
+          actorEnvironemnt.getStore(),
+          this._handlerProvider,
+          this._getDataID,
+        ),
+        reactFlightPayloadDeserializer: null,
+        reactFlightServerErrorHandler: null,
+        scheduler: null,
+        sink,
+        source,
+        store: actorEnvironemnt.getStore(),
+        updater,
+        operationTracker: actorEnvironemnt.getOperationTracker(),
+        getDataID: this._getDataID,
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        shouldProcessClientComponents: false,
+      });
+      return () => executor.cancel();
+    });
+  }
+
+  executeMutation(
+    actorIdentifier: ActorIdentifier,
+    config: ExecuteMutationConfig,
+  ): RelayObservable<GraphQLResponse> {
+    return todo('executeMutation');
+  }
+
+  executeWithSource(
+    actorIdentifier: ActorIdentifier,
+    config: {
+      operation: OperationDescriptor,
+      source: RelayObservable<GraphQLResponse>,
+    },
+  ): RelayObservable<GraphQLResponse> {
+    return todo('executeWithSource');
+  }
+
+  isRequestActive(
+    actorIdentifier: ActorIdentifier,
+    requestIdentifier: string,
+  ): boolean {
+    return todo('isRequestActive');
+  }
+}
+
+module.exports = MultiActorEnvironment;

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

@@ -0,0 +1,196 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {PayloadData, GraphQLResponse} from '../network/RelayNetworkTypes';
+import type RelayObservable from '../network/RelayObservable';
+import type {
+  OperationAvailability,
+  OperationDescriptor,
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Snapshot,
+  StoreUpdater,
+  IEnvironment,
+  ExecuteMutationConfig,
+} from '../store/RelayStoreTypes';
+import type {Disposable} from '../util/RelayRuntimeTypes';
+import type {ActorIdentifier} from './ActorIdentifier';
+
+/**
+ * Interface of actor specific sub-environment
+ */
+export interface IActorEnvironment extends IEnvironment {
+  /**
+   * Reference to the main MultiActorEnvironment that handles
+   * the network execution/and responsible for network integration
+   */
+  +multiActorEnvironment: IMultiActorEnvironment;
+
+  /**
+   * Identifier of the actor for the current active environment
+   */
+  +actorIdentifier: ActorIdentifier;
+}
+
+/**
+ * Interface for the main (or parent) multi-actor environment that contains
+ * the map of individual actor-specific sub-environments. These sub-environments
+ * implement the Relay IEnvironment interface.
+ */
+export interface IMultiActorEnvironment {
+  /**
+   * A factory of actor-specific environments.
+   */
+  forActor(actorIdentifier: ActorIdentifier): IActorEnvironment;
+
+  /**
+   * Determine if the operation can be resolved with data in the store (i.e. no
+   * fields are missing).
+   *
+   * Note that this operation effectively "executes" the selector against the
+   * cache and therefore takes time proportional to the size/complexity of the
+   * selector.
+   */
+  check(
+    actorIdentifier: ActorIdentifier,
+    operation: OperationDescriptor,
+  ): OperationAvailability;
+
+  /**
+   * Subscribe to changes to the results of a selector. The callback is called
+   * when data has been committed to the store that would cause the results of
+   * the snapshot's selector to change.
+   */
+  subscribe(
+    actorIdentifier: ActorIdentifier,
+    snapshot: Snapshot,
+    callback: (snapshot: Snapshot) => void,
+  ): Disposable;
+
+  /**
+   * Ensure that all the records necessary to fulfill the given selector are
+   * retained in-memory. The records will not be eligible for garbage collection
+   * until the returned reference is disposed.
+   */
+  retain(
+    actorIdentifier: ActorIdentifier,
+    operation: OperationDescriptor,
+  ): Disposable;
+
+  /**
+   * Apply an optimistic update to the environment. The mutation can be reverted
+   * by calling `dispose()` on the returned value.
+   */
+  applyUpdate(
+    actorIdentifier: ActorIdentifier,
+    optimisticUpdate: OptimisticUpdateFunction,
+  ): Disposable;
+
+  /**
+   * Apply an optimistic mutation response and/or updater. The mutation can be
+   * reverted by calling `dispose()` on the returned value.
+   */
+  applyMutation(
+    actorIdentifier: ActorIdentifier,
+    optimisticConfig: OptimisticResponseConfig,
+  ): Disposable;
+
+  /**
+   * Commit an updater to the environment. This mutation cannot be reverted and
+   * should therefore not be used for optimistic updates. This is mainly
+   * intended for updating fields from client schema extensions.
+   */
+  commitUpdate(actorIdentifier: ActorIdentifier, updater: StoreUpdater): void;
+
+  /**
+   * Commit a payload to the environment using the given operation selector.
+   */
+  commitPayload(
+    actorIdentifier: ActorIdentifier,
+    operationDescriptor: OperationDescriptor,
+    payload: PayloadData,
+  ): void;
+
+  /**
+   * Read the results of a selector from in-memory records in the store.
+   */
+  lookup(
+    actorIdentifier: ActorIdentifier,
+    selector: SingularReaderSelector,
+  ): Snapshot;
+
+  /**
+   * Send a query to the server with Observer semantics: one or more
+   * responses may be returned (via `next`) over time followed by either
+   * the request completing (`completed`) or an error (`error`).
+   *
+   * Networks/servers that support subscriptions may choose to hold the
+   * subscription open indefinitely such that `complete` is not called.
+   *
+   * Note: Observables are lazy, so calling this method will do nothing until
+   * the result is subscribed to: environment.execute({...}).subscribe({...}).
+   */
+  execute(
+    actorIdentifier: ActorIdentifier,
+    config: {
+      operation: OperationDescriptor,
+      updater?: ?SelectorStoreUpdater,
+    },
+  ): RelayObservable<GraphQLResponse>;
+
+  /**
+   * Returns an Observable of GraphQLResponse resulting from executing the
+   * provided Mutation operation, the result of which is then normalized and
+   * committed to the publish queue along with an optional optimistic response
+   * or updater.
+   *
+   * Note: Observables are lazy, so calling this method will do nothing until
+   * the result is subscribed to:
+   * environment.executeMutation({...}).subscribe({...}).
+   */
+  executeMutation(
+    actorIdentifier: ActorIdentifier,
+    config: ExecuteMutationConfig,
+  ): RelayObservable<GraphQLResponse>;
+
+  /**
+   * Returns an Observable of GraphQLResponse resulting from executing the
+   * provided Query or Subscription operation responses, the result of which is
+   * then normalized and committed to the publish queue.
+   *
+   * Note: Observables are lazy, so calling this method will do nothing until
+   * the result is subscribed to:
+   * environment.executeWithSource({...}).subscribe({...}).
+   */
+  executeWithSource(
+    actorIdentifier: ActorIdentifier,
+    {
+      operation: OperationDescriptor,
+      source: RelayObservable<GraphQLResponse>,
+    },
+  ): RelayObservable<GraphQLResponse>;
+
+  /**
+   * Returns true if a request is currently "active", meaning it's currently
+   * actively receiving payloads or downloading modules, and has not received
+   * a final payload yet. Note that a request might still be pending (or "in flight")
+   * without actively receiving payload, for example a live query or an
+   * active GraphQL subscription
+   */
+  isRequestActive(
+    actorIdentifier: ActorIdentifier,
+    requestIdentifier: string,
+  ): boolean;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const MultiActorEnvironment = require('./MultiActorEnvironment');
+
+export type {ActorIdentifier} from './ActorIdentifier';
+export type {
+  IActorEnvironment,
+  IMultiActorEnvironment,
+} from './MultiActorEnvironmentTypes';
+
+module.exports = {
+  MultiActorEnvironment,
+};

package/mutations/RelayRecordSourceProxy.js.flow

@@ -23,6 +23,7 @@ const {ROOT_ID, ROOT_TYPE} = require('../store/RelayStoreUtils');
 import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
 import type {GetDataID} from '../store/RelayResponseNormalizer';
 import type {
+  DataIDSet,
   HandleFieldPayload,
   RecordSource,
   RecordProxy,
@@ -42,7 +43,7 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
   _proxies: {[dataID: DataID]: ?RelayRecordProxy, ...};
   _getDataID: GetDataID;
   _invalidatedStore: boolean;
-  _idsMarkedForInvalidation: Set<DataID>;
+  _idsMarkedForInvalidation: DataIDSet;
 
   constructor(
     mutator: RelayRecordSourceMutator,
@@ -156,7 +157,7 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
     this._idsMarkedForInvalidation.add(dataID);
   }
 
-  getIDsMarkedForInvalidation(): Set<DataID> {
+  getIDsMarkedForInvalidation(): DataIDSet {
     return this._idsMarkedForInvalidation;
   }
 }

package/mutations/commitMutation.js.flow

@@ -54,7 +54,7 @@ export type DEPRECATED_MutationConfig<T> = {|
 
 export type MutationParameters = {|
   +response: {...},
-  +variables: {...},
+  +variables: interface {},
   +rawResponse?: {...},
 |};
 

package/mutations/validateMutation.js.flow

@@ -32,6 +32,23 @@ const warning = require('warning');
 
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
+const {
+  CONDITION,
+  CLIENT_COMPONENT,
+  CLIENT_EXTENSION,
+  DEFER,
+  FLIGHT_FIELD,
+  FRAGMENT_SPREAD,
+  INLINE_FRAGMENT,
+  LINKED_FIELD,
+  LINKED_HANDLE,
+  MODULE_IMPORT,
+  SCALAR_FIELD,
+  SCALAR_HANDLE,
+  STREAM,
+  TYPE_DISCRIMINATOR,
+} = require('../util/RelayConcreteNode');
+
 let validateMutation = () => {};
 if (__DEV__) {
   const addFieldToDiff = (path: string, diff: Object, isScalar) => {
@@ -96,14 +113,22 @@ if (__DEV__) {
     context: ValidationContext,
   ) => {
     switch (selection.kind) {
-      case 'Condition':
+      case CONDITION:
         validateSelections(optimisticResponse, selection.selections, context);
         return;
-      case 'ScalarField':
-      case 'LinkedField':
-      case 'FlightField':
+      case CLIENT_COMPONENT:
+      case FRAGMENT_SPREAD:
+        validateSelections(
+          optimisticResponse,
+          selection.fragment.selections,
+          context,
+        );
+        return;
+      case SCALAR_FIELD:
+      case LINKED_FIELD:
+      case FLIGHT_FIELD:
         return validateField(optimisticResponse, selection, context);
-      case 'InlineFragment':
+      case INLINE_FRAGMENT:
         const type = selection.type;
         const isConcreteType = selection.abstractKey == null;
         selection.selections.forEach(subselection => {
@@ -113,18 +138,18 @@ if (__DEV__) {
           validateSelection(optimisticResponse, subselection, context);
         });
         return;
-      case 'ClientExtension':
+      case CLIENT_EXTENSION:
         selection.selections.forEach(subselection => {
           validateSelection(optimisticResponse, subselection, context);
         });
         return;
-      case 'ModuleImport':
+      case MODULE_IMPORT:
         return validateModuleImport(context);
-      case 'LinkedHandle':
-      case 'ScalarHandle':
-      case 'Defer':
-      case 'Stream':
-      case 'TypeDiscriminator': {
+      case LINKED_HANDLE:
+      case SCALAR_HANDLE:
+      case DEFER:
+      case STREAM:
+      case TYPE_DISCRIMINATOR: {
         // TODO(T35864292) - Add missing validations for these types
         return;
       }
@@ -147,12 +172,12 @@ if (__DEV__) {
     const path = `${context.path}.${fieldName}`;
     context.visitedPaths.add(path);
     switch (field.kind) {
-      case 'ScalarField':
+      case SCALAR_FIELD:
         if (hasOwnProperty.call(optimisticResponse, fieldName) === false) {
           addFieldToDiff(path, context.missingDiff, true);
         }
         return;
-      case 'LinkedField':
+      case LINKED_FIELD:
         const selections = field.selections;
         if (
           optimisticResponse[fieldName] === null ||
@@ -188,7 +213,7 @@ if (__DEV__) {
             return;
           }
         }
-      case 'FlightField':
+      case FLIGHT_FIELD:
         if (
           optimisticResponse[fieldName] === null ||
           (hasOwnProperty.call(optimisticResponse, fieldName) &&

package/network/RelayNetworkTypes.js.flow

@@ -20,14 +20,15 @@ import type RelayObservable, {ObservableFromValue} from './RelayObservable';
  * An interface for fetching the data for one or more (possibly interdependent)
  * queries.
  */
-export type INetwork = {|
-  execute: ExecuteFunction,
-|};
+export interface INetwork {
+  +execute: ExecuteFunction;
+}
+
 export type LogRequestInfoFunction = mixed => void;
 
-export type PayloadData = {[key: string]: mixed, ...};
+export type PayloadData = interface {[key: string]: mixed};
 
-export type PayloadError = {
+export type PayloadError = interface {
   message: string,
   locations?: Array<{
     line: number,
@@ -36,14 +37,13 @@ export type PayloadError = {
   }>,
   // Not officially part of the spec, but used at Facebook
   severity?: 'CRITICAL' | 'ERROR' | 'WARNING',
-  ...
 };
 
 export type PayloadExtensions = {[key: string]: mixed, ...};
 
 /**
  * The shape of a GraphQL response as dictated by the
- * [spec](https://graphql.github.io/graphql-spec/June2018/#sec-Response-Format)
+ * [spec](https://spec.graphql.org/June2018/#sec-Response-Format).
  */
 export type GraphQLResponseWithData = {|
   +data: PayloadData,
@@ -120,7 +120,7 @@ export type SubscribeFunction = (
 ) => RelayObservable<GraphQLResponse>;
 
 export type Uploadable = File | Blob;
-export type UploadableMap = {[key: string]: Uploadable, ...};
+export type UploadableMap = interface {[key: string]: Uploadable};
 
 /**
  * React Flight tree created on the server.
@@ -132,14 +132,34 @@ export type ReactFlightPayloadQuery = {|
   +response: GraphQLSingularResponse,
   +variables: Variables,
 |};
+export type ReactFlightPayloadFragment = {|
+  +__id: string,
+  +__typename: string,
+  +module: mixed,
+  +response: GraphQLSingularResponse,
+  +variables: Variables,
+|};
+export type ReactFlightServerError = {
+  +message: string,
+  +stack: string,
+  ...
+};
 /**
  * Data that is returned by a Flight compliant GraphQL server.
  *
- * - tree: an array of values that will be iterated and fed into
- *     ReactFlightDOMRelayClient.
+ * - status: string representing status of the server response.
+ * - tree: React Server Components written into a row protocol that can be later
+ *         read on the client. If this is null, this indicates that no rows were
+ *         were written on the server.
  * - queries: an array of queries that the server preloaded for the client.
+ * - errors: an array of errors that were encountered while rendering the
+ *           Server Component.
+ * - fragments: an array of fragments that the server preloaded for the client.
  */
 export type ReactFlightPayloadData = {|
-  +tree: Array<ReactFlightServerTree>,
+  +status: string,
+  +tree: ?Array<ReactFlightServerTree>,
   +queries: Array<ReactFlightPayloadQuery>,
+  +errors: Array<ReactFlightServerError>,
+  +fragments: Array<ReactFlightPayloadFragment>,
 |};

package/network/RelayQueryResponseCache.js.flow

@@ -64,7 +64,8 @@ class RelayQueryResponseCache {
     });
     const response = this._responses.get(cacheKey);
     return response != null
-      ? ({
+      ? // $FlowFixMe[speculation-ambiguous]
+        ({
           ...response.payload,
           extensions: {
             ...response.payload.extensions,