relay-runtime 11.0.1 → 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/network/RelayNetworkTypes.js.flow

@@ -20,9 +20,10 @@ 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 = interface {[key: string]: mixed};
@@ -42,7 +43,7 @@ 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,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "11.0.1",
+  "version": "11.0.2",
   "keywords": [
     "graphql",
     "relay"
@@ -12,7 +12,8 @@
   "repository": "facebook/relay",
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "fbjs": "^3.0.0"
+    "fbjs": "^3.0.0",
+    "invariant": "^2.2.4"
   },
   "directories": {
     "": "./"