relay-runtime 8.0.0 → 10.0.1

package/store/RelayOperationTracker.js.flow

@@ -0,0 +1,164 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+import type {RequestDescriptor} from './RelayStoreTypes';
+
+class RelayOperationTracker {
+  _ownersToPendingOperations: Map<RequestDescriptor, Set<RequestDescriptor>>;
+  _pendingOperationsToOwners: Map<RequestDescriptor, Set<RequestDescriptor>>;
+  _ownersToPromise: Map<
+    RequestDescriptor,
+    {|promise: Promise<void>, resolve: () => void|},
+  >;
+
+  constructor() {
+    this._ownersToPendingOperations = new Map();
+    this._pendingOperationsToOwners = new Map();
+    this._ownersToPromise = new Map();
+  }
+
+  /**
+   * Update the map of current processing operations with the set of
+   * affected owners and notify subscribers
+   */
+  update(
+    pendingOperation: RequestDescriptor,
+    affectedOwners: Set<RequestDescriptor>,
+  ): void {
+    if (affectedOwners.size === 0) {
+      return;
+    }
+    const newlyAffectedOwners = new Set();
+    for (const owner of affectedOwners) {
+      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(
+        owner,
+      );
+      if (pendingOperationsAffectingOwner != null) {
+        // In this case the `owner` already affected by some operations
+        // We just need to detect, is it the same operation that we already
+        // have in the list, or it's a new operation
+        if (!pendingOperationsAffectingOwner.has(pendingOperation)) {
+          pendingOperationsAffectingOwner.add(pendingOperation);
+          newlyAffectedOwners.add(owner);
+        }
+      } else {
+        // This is a new `owner` that is affected by the operation
+        this._ownersToPendingOperations.set(owner, new Set([pendingOperation]));
+        newlyAffectedOwners.add(owner);
+      }
+    }
+
+    // No new owners were affected by this operation, we may stop here
+    if (newlyAffectedOwners.size === 0) {
+      return;
+    }
+
+    // But, if some owners were affected we need to add them to
+    // the `_pendingOperationsToOwners` set
+    const ownersAffectedByOperation =
+      this._pendingOperationsToOwners.get(pendingOperation) || new Set();
+
+    for (const owner of newlyAffectedOwners) {
+      this._resolveOwnerResolvers(owner);
+      ownersAffectedByOperation.add(owner);
+    }
+    this._pendingOperationsToOwners.set(
+      pendingOperation,
+      ownersAffectedByOperation,
+    );
+  }
+
+  /**
+   * Once pending operation is completed we need to remove it
+   * from all tracking maps
+   */
+  complete(pendingOperation: RequestDescriptor): void {
+    const affectedOwners = this._pendingOperationsToOwners.get(
+      pendingOperation,
+    );
+    if (affectedOwners == null) {
+      return;
+    }
+    // These were the owners affected only by `pendingOperation`
+    const completedOwners = new Set();
+
+    // These were the owners affected by `pendingOperation`
+    // and some other operations
+    const updatedOwners = new Set();
+    for (const owner of affectedOwners) {
+      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(
+        owner,
+      );
+      if (!pendingOperationsAffectingOwner) {
+        continue;
+      }
+      pendingOperationsAffectingOwner.delete(pendingOperation);
+      if (pendingOperationsAffectingOwner.size > 0) {
+        updatedOwners.add(owner);
+      } else {
+        completedOwners.add(owner);
+      }
+    }
+
+    // Complete subscriptions for all owners, affected by `pendingOperation`
+    for (const owner of completedOwners) {
+      this._resolveOwnerResolvers(owner);
+      this._ownersToPendingOperations.delete(owner);
+    }
+
+    // Update all owner that were updated by `pendingOperation` but still
+    // are affected by other operations
+    for (const owner of updatedOwners) {
+      this._resolveOwnerResolvers(owner);
+    }
+
+    // Finally, remove pending operation
+    this._pendingOperationsToOwners.delete(pendingOperation);
+  }
+
+  _resolveOwnerResolvers(owner: RequestDescriptor): void {
+    const promiseEntry = this._ownersToPromise.get(owner);
+    if (promiseEntry != null) {
+      promiseEntry.resolve();
+    }
+    this._ownersToPromise.delete(owner);
+  }
+
+  getPromiseForPendingOperationsAffectingOwner(
+    owner: RequestDescriptor,
+  ): Promise<void> | null {
+    if (!this._ownersToPendingOperations.has(owner)) {
+      return null;
+    }
+    const cachedPromiseEntry = this._ownersToPromise.get(owner);
+    if (cachedPromiseEntry != null) {
+      return cachedPromiseEntry.promise;
+    }
+    let resolve;
+    const promise = new Promise(r => {
+      resolve = r;
+    });
+    invariant(
+      resolve != null,
+      'RelayOperationTracker: Expected resolver to be defined. If you' +
+        'are seeing this, it is likely a bug in Relay.',
+    );
+    this._ownersToPromise.set(owner, {promise, resolve});
+    return promise;
+  }
+}
+
+module.exports = RelayOperationTracker;

package/store/RelayOptimisticRecordSource.js.flow

@@ -0,0 +1,119 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const RelayRecordSource = require('./RelayRecordSource');
+
+import type {DataID} from '../util/RelayRuntimeTypes';
+import type {RecordState} from './RelayRecordState';
+import type {
+  MutableRecordSource,
+  Record,
+  RecordSource,
+} from './RelayStoreTypes';
+
+const UNPUBLISH_RECORD_SENTINEL = Object.freeze({
+  __UNPUBLISH_RECORD_SENTINEL: true,
+});
+
+/**
+ * An implementation of MutableRecordSource that represents a base RecordSource
+ * with optimistic updates stacked on top: records with optimistic updates
+ * shadow the base version of the record rather than updating/replacing them.
+ */
+class RelayOptimisticRecordSource implements MutableRecordSource {
+  _base: RecordSource;
+  _sink: MutableRecordSource;
+
+  constructor(base: RecordSource): void {
+    this._base = base;
+    this._sink = RelayRecordSource.create();
+  }
+
+  has(dataID: DataID): boolean {
+    if (this._sink.has(dataID)) {
+      const sinkRecord = this._sink.get(dataID);
+      return sinkRecord !== UNPUBLISH_RECORD_SENTINEL;
+    } else {
+      return this._base.has(dataID);
+    }
+  }
+
+  get(dataID: DataID): ?Record {
+    if (this._sink.has(dataID)) {
+      const sinkRecord = this._sink.get(dataID);
+      if (sinkRecord === UNPUBLISH_RECORD_SENTINEL) {
+        return undefined;
+      } else {
+        return sinkRecord;
+      }
+    } else {
+      return this._base.get(dataID);
+    }
+  }
+
+  getStatus(dataID: DataID): RecordState {
+    const record = this.get(dataID);
+    if (record === undefined) {
+      return 'UNKNOWN';
+    } else if (record === null) {
+      return 'NONEXISTENT';
+    } else {
+      return 'EXISTENT';
+    }
+  }
+
+  clear(): void {
+    this._base = RelayRecordSource.create();
+    this._sink.clear();
+  }
+
+  delete(dataID: DataID): void {
+    this._sink.delete(dataID);
+  }
+
+  remove(dataID: DataID): void {
+    this._sink.set(dataID, UNPUBLISH_RECORD_SENTINEL);
+  }
+
+  set(dataID: DataID, record: Record): void {
+    this._sink.set(dataID, record);
+  }
+
+  getRecordIDs(): Array<DataID> {
+    return Object.keys(this.toJSON());
+  }
+
+  size(): number {
+    return Object.keys(this.toJSON()).length;
+  }
+
+  toJSON() {
+    const merged = {...this._base.toJSON()};
+    this._sink.getRecordIDs().forEach(dataID => {
+      const record = this.get(dataID);
+      if (record === undefined) {
+        delete merged[dataID];
+      } else {
+        merged[dataID] = record;
+      }
+    });
+    return merged;
+  }
+}
+
+function create(base: RecordSource): MutableRecordSource {
+  return new RelayOptimisticRecordSource(base);
+}
+
+module.exports = {create};

package/store/RelayPublishQueue.js.flow

@@ -0,0 +1,401 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const ErrorUtils = require('ErrorUtils');
+const RelayReader = require('./RelayReader');
+const RelayRecordSource = require('./RelayRecordSource');
+const RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
+const RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
+const RelayRecordSourceSelectorProxy = require('../mutations/RelayRecordSourceSelectorProxy');
+
+const invariant = require('invariant');
+const warning = require('warning');
+
+import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
+import type {Disposable} from '../util/RelayRuntimeTypes';
+import type {GetDataID} from './RelayResponseNormalizer';
+import type {
+  OperationDescriptor,
+  OptimisticUpdate,
+  PublishQueue,
+  RecordSource,
+  RelayResponsePayload,
+  RequestDescriptor,
+  SelectorData,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Store,
+  StoreUpdater,
+} from './RelayStoreTypes';
+
+type PendingCommit = PendingRelayPayload | PendingRecordSource | PendingUpdater;
+type PendingRelayPayload = {|
+  +kind: 'payload',
+  +operation: OperationDescriptor,
+  +payload: RelayResponsePayload,
+  +updater: ?SelectorStoreUpdater,
+|};
+type PendingRecordSource = {|
+  +kind: 'source',
+  +source: RecordSource,
+|};
+type PendingUpdater = {|
+  +kind: 'updater',
+  +updater: StoreUpdater,
+|};
+
+/**
+ * Coordinates the concurrent modification of a `Store` due to optimistic and
+ * non-revertable client updates and server payloads:
+ * - Applies optimistic updates.
+ * - Reverts optimistic updates, rebasing any subsequent updates.
+ * - Commits client updates (typically for client schema extensions).
+ * - Commits server updates:
+ *   - Normalizes query/mutation/subscription responses.
+ *   - Executes handlers for "handle" fields.
+ *   - Reverts and reapplies pending optimistic updates.
+ */
+class RelayPublishQueue implements PublishQueue {
+  _store: Store;
+  _handlerProvider: ?HandlerProvider;
+  _getDataID: GetDataID;
+
+  _hasStoreSnapshot: boolean;
+  // True if the next `run()` should apply the backup and rerun all optimistic
+  // updates performing a rebase.
+  _pendingBackupRebase: boolean;
+  // Payloads to apply or Sources to publish to the store with the next `run()`.
+  _pendingData: Set<PendingCommit>;
+  // Optimistic updaters to add with the next `run()`.
+  _pendingOptimisticUpdates: Set<OptimisticUpdate>;
+  // Optimistic updaters that are already added and might be rerun in order to
+  // rebase them.
+  _appliedOptimisticUpdates: Set<OptimisticUpdate>;
+  // Garbage collection hold, should rerun gc on dispose
+  _gcHold: ?Disposable;
+  _isRunning: ?boolean;
+
+  constructor(
+    store: Store,
+    handlerProvider?: ?HandlerProvider,
+    getDataID: GetDataID,
+  ) {
+    this._hasStoreSnapshot = false;
+    this._handlerProvider = handlerProvider || null;
+    this._pendingBackupRebase = false;
+    this._pendingData = new Set();
+    this._pendingOptimisticUpdates = new Set();
+    this._store = store;
+    this._appliedOptimisticUpdates = new Set();
+    this._gcHold = null;
+    this._getDataID = getDataID;
+  }
+
+  /**
+   * Schedule applying an optimistic updates on the next `run()`.
+   */
+  applyUpdate(updater: OptimisticUpdate): void {
+    invariant(
+      !this._appliedOptimisticUpdates.has(updater) &&
+        !this._pendingOptimisticUpdates.has(updater),
+      'RelayPublishQueue: Cannot apply the same update function more than ' +
+        'once concurrently.',
+    );
+    this._pendingOptimisticUpdates.add(updater);
+  }
+
+  /**
+   * Schedule reverting an optimistic updates on the next `run()`.
+   */
+  revertUpdate(updater: OptimisticUpdate): void {
+    if (this._pendingOptimisticUpdates.has(updater)) {
+      // Reverted before it was applied
+      this._pendingOptimisticUpdates.delete(updater);
+    } else if (this._appliedOptimisticUpdates.has(updater)) {
+      this._pendingBackupRebase = true;
+      this._appliedOptimisticUpdates.delete(updater);
+    }
+  }
+
+  /**
+   * Schedule a revert of all optimistic updates on the next `run()`.
+   */
+  revertAll(): void {
+    this._pendingBackupRebase = true;
+    this._pendingOptimisticUpdates.clear();
+    this._appliedOptimisticUpdates.clear();
+  }
+
+  /**
+   * Schedule applying a payload to the store on the next `run()`.
+   */
+  commitPayload(
+    operation: OperationDescriptor,
+    payload: RelayResponsePayload,
+    updater?: ?SelectorStoreUpdater,
+  ): void {
+    this._pendingBackupRebase = true;
+    this._pendingData.add({
+      kind: 'payload',
+      operation,
+      payload,
+      updater,
+    });
+  }
+
+  /**
+   * Schedule an updater to mutate the store on the next `run()` typically to
+   * update client schema fields.
+   */
+  commitUpdate(updater: StoreUpdater): void {
+    this._pendingBackupRebase = true;
+    this._pendingData.add({
+      kind: 'updater',
+      updater,
+    });
+  }
+
+  /**
+   * Schedule a publish to the store from the provided source on the next
+   * `run()`. As an example, to update the store with substituted fields that
+   * are missing in the store.
+   */
+  commitSource(source: RecordSource): void {
+    this._pendingBackupRebase = true;
+    this._pendingData.add({kind: 'source', source});
+  }
+
+  /**
+   * Execute all queued up operations from the other public methods.
+   */
+  run(
+    sourceOperation?: OperationDescriptor,
+  ): $ReadOnlyArray<RequestDescriptor> {
+    if (__DEV__) {
+      warning(
+        this._isRunning !== true,
+        'A store update was detected within another store update. Please ' +
+          'make sure new store updates aren’t being executed within an ' +
+          'updater function for a different update.',
+      );
+      this._isRunning = true;
+    }
+    if (this._pendingBackupRebase) {
+      if (this._hasStoreSnapshot) {
+        this._store.restore();
+        this._hasStoreSnapshot = false;
+      }
+    }
+    const invalidatedStore = this._commitData();
+    if (
+      this._pendingOptimisticUpdates.size ||
+      (this._pendingBackupRebase && this._appliedOptimisticUpdates.size)
+    ) {
+      if (!this._hasStoreSnapshot) {
+        this._store.snapshot();
+        this._hasStoreSnapshot = true;
+      }
+      this._applyUpdates();
+    }
+    this._pendingBackupRebase = false;
+    if (this._appliedOptimisticUpdates.size > 0) {
+      if (!this._gcHold) {
+        this._gcHold = this._store.holdGC();
+      }
+    } else {
+      if (this._gcHold) {
+        this._gcHold.dispose();
+        this._gcHold = null;
+      }
+    }
+    if (__DEV__) {
+      this._isRunning = false;
+    }
+    return this._store.notify(sourceOperation, invalidatedStore);
+  }
+
+  /**
+   * _publishSourceFromPayload will return a boolean indicating if the
+   * publish caused the store to be globally invalidated.
+   */
+  _publishSourceFromPayload(pendingPayload: PendingRelayPayload): boolean {
+    const {payload, operation, updater} = pendingPayload;
+    const {source, fieldPayloads} = payload;
+    const mutator = new RelayRecordSourceMutator(
+      this._store.getSource(),
+      source,
+    );
+    const recordSourceProxy = new RelayRecordSourceProxy(
+      mutator,
+      this._getDataID,
+    );
+    if (fieldPayloads && fieldPayloads.length) {
+      fieldPayloads.forEach(fieldPayload => {
+        const handler =
+          this._handlerProvider && this._handlerProvider(fieldPayload.handle);
+        invariant(
+          handler,
+          'RelayModernEnvironment: Expected a handler to be provided for ' +
+            'handle `%s`.',
+          fieldPayload.handle,
+        );
+        handler.update(recordSourceProxy, fieldPayload);
+      });
+    }
+    if (updater) {
+      const selector = operation.fragment;
+      invariant(
+        selector != null,
+        'RelayModernEnvironment: Expected a selector to be provided with updater function.',
+      );
+      const recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(
+        mutator,
+        recordSourceProxy,
+        selector,
+      );
+      const selectorData = lookupSelector(source, selector);
+      updater(recordSourceSelectorProxy, selectorData);
+    }
+    const idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();
+    this._store.publish(source, idsMarkedForInvalidation);
+    return recordSourceProxy.isStoreMarkedForInvalidation();
+  }
+
+  /**
+   * _commitData will return a boolean indicating if any of
+   * the pending commits caused the store to be globally invalidated.
+   */
+  _commitData(): boolean {
+    if (!this._pendingData.size) {
+      return false;
+    }
+    let invalidatedStore = false;
+    this._pendingData.forEach(data => {
+      if (data.kind === 'payload') {
+        const payloadInvalidatedStore = this._publishSourceFromPayload(data);
+        invalidatedStore = invalidatedStore || payloadInvalidatedStore;
+      } else if (data.kind === 'source') {
+        const source = data.source;
+        this._store.publish(source);
+      } else {
+        const updater = data.updater;
+        const sink = RelayRecordSource.create();
+        const mutator = new RelayRecordSourceMutator(
+          this._store.getSource(),
+          sink,
+        );
+        const recordSourceProxy = new RelayRecordSourceProxy(
+          mutator,
+          this._getDataID,
+        );
+        ErrorUtils.applyWithGuard(
+          updater,
+          null,
+          [recordSourceProxy],
+          null,
+          'RelayPublishQueue:commitData',
+        );
+        invalidatedStore =
+          invalidatedStore || recordSourceProxy.isStoreMarkedForInvalidation();
+        const idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();
+
+        this._store.publish(sink, idsMarkedForInvalidation);
+      }
+    });
+    this._pendingData.clear();
+    return invalidatedStore;
+  }
+
+  /**
+   * Note that unlike _commitData, _applyUpdates will NOT return a boolean
+   * indicating if the store was globally invalidated, since invalidating the
+   * store during an optimistic update is a no-op.
+   */
+  _applyUpdates(): void {
+    const sink = RelayRecordSource.create();
+    const mutator = new RelayRecordSourceMutator(this._store.getSource(), sink);
+    const recordSourceProxy = new RelayRecordSourceProxy(
+      mutator,
+      this._getDataID,
+      this._handlerProvider,
+    );
+
+    const processUpdate = optimisticUpdate => {
+      if (optimisticUpdate.storeUpdater) {
+        const {storeUpdater} = optimisticUpdate;
+        ErrorUtils.applyWithGuard(
+          storeUpdater,
+          null,
+          [recordSourceProxy],
+          null,
+          'RelayPublishQueue:applyUpdates',
+        );
+      } else {
+        const {operation, payload, updater} = optimisticUpdate;
+        const {source, fieldPayloads} = payload;
+        const recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(
+          mutator,
+          recordSourceProxy,
+          operation.fragment,
+        );
+        let selectorData;
+        if (source) {
+          recordSourceProxy.publishSource(source, fieldPayloads);
+          selectorData = lookupSelector(source, operation.fragment);
+        }
+        if (updater) {
+          ErrorUtils.applyWithGuard(
+            updater,
+            null,
+            [recordSourceSelectorProxy, selectorData],
+            null,
+            'RelayPublishQueue:applyUpdates',
+          );
+        }
+      }
+    };
+
+    // rerun all updaters in case we are running a rebase
+    if (this._pendingBackupRebase && this._appliedOptimisticUpdates.size) {
+      this._appliedOptimisticUpdates.forEach(processUpdate);
+    }
+
+    // apply any new updaters
+    if (this._pendingOptimisticUpdates.size) {
+      this._pendingOptimisticUpdates.forEach(optimisticUpdate => {
+        processUpdate(optimisticUpdate);
+        this._appliedOptimisticUpdates.add(optimisticUpdate);
+      });
+      this._pendingOptimisticUpdates.clear();
+    }
+
+    this._store.publish(sink);
+  }
+}
+
+function lookupSelector(
+  source: RecordSource,
+  selector: SingularReaderSelector,
+): ?SelectorData {
+  const selectorData = RelayReader.read(source, selector).data;
+  if (__DEV__) {
+    const deepFreeze = require('../util/deepFreeze');
+    if (selectorData) {
+      deepFreeze(selectorData);
+    }
+  }
+  return selectorData;
+}
+
+module.exports = RelayPublishQueue;