relay-runtime 11.0.0-rc.0 → 12.0.0

package/util/RelayReplaySubject.js.flow

@@ -42,7 +42,7 @@ class RelayReplaySubject<T> {
   _events: Array<Event<T>> = [];
   _sinks: Set<Sink<T>> = new Set();
   _observable: RelayObservable<T>;
-  _subscription: ?Subscription = null;
+  _subscription: Array<Subscription> = [];
 
   constructor() {
     this._observable = RelayObservable.create(sink => {
@@ -116,15 +116,16 @@ class RelayReplaySubject<T> {
   }
 
   subscribe(observer: Observer<T> | Sink<T>): Subscription {
-    this._subscription = this._observable.subscribe(observer);
-    return this._subscription;
+    const subscription = this._observable.subscribe(observer);
+    this._subscription.push(subscription);
+    return subscription;
   }
 
   unsubscribe() {
-    if (this._subscription) {
-      this._subscription.unsubscribe();
-      this._subscription = null;
+    for (const subscription of this._subscription) {
+      subscription.unsubscribe();
     }
+    this._subscription = [];
   }
 
   getObserverCount(): number {

package/util/RelayRuntimeTypes.js.flow

@@ -21,12 +21,12 @@
  * use-case is as a return value for subscriptions, where calling `dispose()`
  * would cancel the subscription.
  */
-export type Disposable = {dispose(): void, ...};
+export type Disposable = interface {dispose(): void};
 
 export type DataID = string;
 
 // Variables
-export type Variables = {+[string]: $FlowFixMe, ...};
+export type Variables = {+[string]: $FlowFixMe};
 
 /**
  * Generated operation flow types are subtypes of this.
@@ -49,6 +49,7 @@ export type VariablesOf<T: OperationType> = $ElementType<T, 'variables'>;
  *   in milliseconds. (This value will be passed to setTimeout.)
  * - `liveConfigId`: causes a query to live update by calling GraphQLLiveQuery,
  *   it represents a configuration of gateway when doing live query
+ * - `onSubscribe`: Not in use.
  * - `metadata`: user-supplied metadata.
  * - `transactionId`: a user-supplied value, intended for use as a unique id for
  *   a given instance of executing an operation.
@@ -57,6 +58,7 @@ export type CacheConfig = {|
   force?: ?boolean,
   poll?: ?number,
   liveConfigId?: ?string,
+  onSubscribe?: () => void,
   metadata?: {[key: string]: mixed, ...},
   transactionId?: ?string,
 |};

package/util/deepFreeze.js.flow

@@ -18,9 +18,10 @@
  * For convenience, and for consistency with the behavior of `Object.freeze`,
  * returns the now-frozen original object.
  */
-function deepFreeze<T: {...}>(object: T): T {
+function deepFreeze<T: interface {}>(object: T): T {
   Object.freeze(object);
   Object.getOwnPropertyNames(object).forEach(name => {
+    // $FlowFixMe[prop-missing]
     const property = object[name];
     if (
       property &&

package/util/getPaginationMetadata.js.flow

@@ -0,0 +1,74 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const getRefetchMetadata = require('./getRefetchMetadata');
+const invariant = require('invariant');
+
+import type {
+  ConcreteRequest,
+  ReaderFragment,
+  ReaderPaginationMetadata,
+} from 'relay-runtime';
+
+function getPaginationMetadata(
+  fragmentNode: ReaderFragment,
+  componentDisplayName: string,
+): {|
+  connectionPathInFragmentData: $ReadOnlyArray<string | number>,
+  identifierField: ?string,
+  paginationRequest: ConcreteRequest,
+  paginationMetadata: ReaderPaginationMetadata,
+  stream: boolean,
+|} {
+  const {
+    refetchableRequest: paginationRequest,
+    refetchMetadata,
+  } = getRefetchMetadata(fragmentNode, componentDisplayName);
+
+  const paginationMetadata = refetchMetadata.connection;
+  invariant(
+    paginationMetadata != null,
+    'Relay: getPaginationMetadata(): Expected fragment `%s` to include a ' +
+      'connection when using `%s`. Did you forget to add a @connection ' +
+      'directive to the connection field in the fragment?',
+    componentDisplayName,
+    fragmentNode.name,
+  );
+  const connectionPathInFragmentData = paginationMetadata.path;
+
+  const connectionMetadata = (fragmentNode.metadata?.connection ?? [])[0];
+  invariant(
+    connectionMetadata != null,
+    'Relay: getPaginationMetadata(): Expected fragment `%s` to include a ' +
+      'connection when using `%s`. Did you forget to add a @connection ' +
+      'directive to the connection field in the fragment?',
+    componentDisplayName,
+    fragmentNode.name,
+  );
+  const identifierField = refetchMetadata.identifierField;
+  invariant(
+    identifierField == null || typeof identifierField === 'string',
+    'Relay: getRefetchMetadata(): Expected `identifierField` to be a string.',
+  );
+  return {
+    connectionPathInFragmentData,
+    identifierField,
+    paginationRequest,
+    paginationMetadata,
+    stream: connectionMetadata.stream === true,
+  };
+}
+
+module.exports = getPaginationMetadata;

package/util/getPaginationVariables.js.flow

@@ -0,0 +1,112 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+const warning = require('warning');
+
+import type {ReaderPaginationMetadata} from './ReaderNode';
+import type {Variables} from './RelayRuntimeTypes';
+
+export type Direction = 'forward' | 'backward';
+
+function getPaginationVariables(
+  direction: Direction,
+  count: number,
+  cursor: ?string,
+  baseVariables: Variables,
+  extraVariables: Variables,
+  paginationMetadata: ReaderPaginationMetadata,
+): {[string]: mixed, ...} {
+  const {
+    backward: backwardMetadata,
+    forward: forwardMetadata,
+  } = paginationMetadata;
+
+  if (direction === 'backward') {
+    invariant(
+      backwardMetadata != null &&
+        backwardMetadata.count != null &&
+        backwardMetadata.cursor != null,
+      'Relay: Expected backward pagination metadata to be available. ' +
+        "If you're seeing this, this is likely a bug in Relay.",
+    );
+    warning(
+      !extraVariables.hasOwnProperty(backwardMetadata.cursor),
+      'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+        'contain cursor variable `%s`. This variable is automatically ' +
+        'determined by Relay.',
+      backwardMetadata.cursor,
+    );
+    warning(
+      !extraVariables.hasOwnProperty(backwardMetadata.count),
+      'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+        'contain count variable `%s`. This variable is automatically ' +
+        'determined by Relay.',
+      backwardMetadata.count,
+    );
+    // $FlowFixMe[cannot-spread-interface]
+    const paginationVariables = {
+      ...baseVariables,
+      ...extraVariables,
+      [backwardMetadata.cursor]: cursor,
+      [backwardMetadata.count]: count,
+    };
+    if (forwardMetadata && forwardMetadata.cursor) {
+      paginationVariables[forwardMetadata.cursor] = null;
+    }
+    if (forwardMetadata && forwardMetadata.count) {
+      paginationVariables[forwardMetadata.count] = null;
+    }
+    return paginationVariables;
+  }
+
+  invariant(
+    forwardMetadata != null &&
+      forwardMetadata.count != null &&
+      forwardMetadata.cursor != null,
+    'Relay: Expected forward pagination metadata to be available. ' +
+      "If you're seeing this, this is likely a bug in Relay.",
+  );
+  warning(
+    !extraVariables.hasOwnProperty(forwardMetadata.cursor),
+    'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+      'contain cursor variable `%s`. This variable is automatically ' +
+      'determined by Relay.',
+    forwardMetadata.cursor,
+  );
+  warning(
+    !extraVariables.hasOwnProperty(forwardMetadata.count),
+    'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+      'contain count variable `%s`. This variable is automatically ' +
+      'determined by Relay.',
+    forwardMetadata.count,
+  );
+  // $FlowFixMe[cannot-spread-interface]
+  const paginationVariables = {
+    ...baseVariables,
+    ...extraVariables,
+    [forwardMetadata.cursor]: cursor,
+    [forwardMetadata.count]: count,
+  };
+  if (backwardMetadata && backwardMetadata.cursor) {
+    paginationVariables[backwardMetadata.cursor] = null;
+  }
+  if (backwardMetadata && backwardMetadata.count) {
+    paginationVariables[backwardMetadata.count] = null;
+  }
+  return paginationVariables;
+}
+
+module.exports = getPaginationVariables;

package/util/getPendingOperationsForFragment.js.flow

@@ -0,0 +1,62 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {getPromiseForActiveRequest} = require('../query/fetchQueryInternal');
+
+import type {IEnvironment, RequestDescriptor} from '../store/RelayStoreTypes';
+import type {ReaderFragment} from './ReaderNode';
+
+function getPendingOperationsForFragment(
+  environment: IEnvironment,
+  fragmentNode: ReaderFragment,
+  fragmentOwner: RequestDescriptor,
+): {|
+  promise: Promise<void>,
+  pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+|} | null {
+  let pendingOperations: $ReadOnlyArray<RequestDescriptor> = [];
+  let promise = getPromiseForActiveRequest(environment, fragmentOwner);
+
+  if (promise != null) {
+    pendingOperations = [fragmentOwner];
+  } else {
+    const result = environment
+      .getOperationTracker()
+      .getPendingOperationsAffectingOwner(fragmentOwner);
+
+    pendingOperations = result?.pendingOperations ?? [];
+    promise = result?.promise ?? null;
+  }
+
+  if (!promise) {
+    return null;
+  }
+
+  let pendingOperationName =
+    pendingOperations?.map(op => op.node.params.name).join(',') ?? null;
+  if (pendingOperationName == null || pendingOperationName.length === 0) {
+    pendingOperationName = 'Unknown pending operation';
+  }
+  const fragmentName = fragmentNode.name;
+  const promiseDisplayName =
+    pendingOperationName === fragmentName
+      ? `Relay(${pendingOperationName})`
+      : `Relay(${pendingOperationName}:${fragmentName})`;
+  // $FlowExpectedError[prop-missing] Expando to annotate Promises.
+  promise.displayName = promiseDisplayName;
+  return {promise, pendingOperations};
+}
+
+module.exports = getPendingOperationsForFragment;

package/util/getRefetchMetadata.js.flow

@@ -0,0 +1,80 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+import type {
+  ConcreteRequest,
+  ReaderFragment,
+  ReaderRefetchMetadata,
+} from 'relay-runtime';
+
+function getRefetchMetadata(
+  fragmentNode: ReaderFragment,
+  componentDisplayName: string,
+): {|
+  fragmentRefPathInResponse: $ReadOnlyArray<string | number>,
+  identifierField: ?string,
+  refetchableRequest: ConcreteRequest,
+  refetchMetadata: ReaderRefetchMetadata,
+|} {
+  invariant(
+    fragmentNode.metadata?.plural !== true,
+    'Relay: getRefetchMetadata(): Expected fragment `%s` not to be plural when using ' +
+      '`%s`. Remove `@relay(plural: true)` from fragment `%s` ' +
+      'in order to use it with `%s`.',
+    fragmentNode.name,
+    componentDisplayName,
+    fragmentNode.name,
+    componentDisplayName,
+  );
+
+  const refetchMetadata = fragmentNode.metadata?.refetch;
+  invariant(
+    refetchMetadata != null,
+    'Relay: getRefetchMetadata(): Expected fragment `%s` to be refetchable when using `%s`. ' +
+      'Did you forget to add a @refetchable directive to the fragment?',
+    componentDisplayName,
+    fragmentNode.name,
+  );
+
+  // handle both commonjs and es modules
+  const refetchableRequest:
+    | ConcreteRequest
+    | string = (refetchMetadata: $FlowFixMe).operation.default
+    ? (refetchMetadata: $FlowFixMe).operation.default
+    : refetchMetadata.operation;
+  const fragmentRefPathInResponse = refetchMetadata.fragmentPathInResult;
+  invariant(
+    typeof refetchableRequest !== 'string',
+    'Relay: getRefetchMetadata(): Expected refetch query to be an ' +
+      "operation and not a string when using `%s`. If you're seeing this, " +
+      'this is likely a bug in Relay.',
+    componentDisplayName,
+  );
+  const identifierField = refetchMetadata.identifierField;
+  invariant(
+    identifierField == null || typeof identifierField === 'string',
+    'Relay: getRefetchMetadata(): Expected `identifierField` to be a string.',
+  );
+  return {
+    fragmentRefPathInResponse,
+    identifierField,
+    refetchableRequest,
+    refetchMetadata,
+  };
+}
+
+module.exports = getRefetchMetadata;

package/util/getValueAtPath.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+function getValueAtPath(
+  data: mixed,
+  path: $ReadOnlyArray<string | number>,
+): mixed {
+  let result = data;
+  for (const key of path) {
+    if (result == null) {
+      return null;
+    }
+    if (typeof key === 'number') {
+      invariant(
+        Array.isArray(result),
+        'Relay: Expected an array when extracting value at path. ' +
+          "If you're seeing this, this is likely a bug in Relay.",
+      );
+      result = result[key];
+    } else {
+      invariant(
+        typeof result === 'object' && !Array.isArray(result),
+        'Relay: Expected an object when extracting value at path. ' +
+          "If you're seeing this, this is likely a bug in Relay.",
+      );
+      result = result[key];
+    }
+  }
+  return result;
+}
+
+module.exports = getValueAtPath;

package/util/isEmptyObject.js.flow

@@ -11,9 +11,10 @@
 
 'use strict';
 
+// $FlowFixMe[method-unbinding] added when improving typing for this parameters
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-function isEmptyObject(obj: {+[key: string]: mixed}): boolean {
+function isEmptyObject(obj: interface {+[key: string]: mixed}): boolean {
   for (const key in obj) {
     if (hasOwnProperty.call(obj, key)) {
       return false;

package/util/registerEnvironmentWithDevTools.js.flow

@@ -0,0 +1,33 @@
+/**
+ * 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
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {IEnvironment} from '../store/RelayStoreTypes';
+
+function registerEnvironmentWithDevTools(environment: IEnvironment): void {
+  // Register this Relay Environment with Relay DevTools if it exists.
+  // Note: this must always be the last step in the constructor.
+  const _global =
+    typeof global !== 'undefined'
+      ? global
+      : typeof window !== 'undefined'
+      ? window
+      : undefined;
+  const devToolsHook = _global && _global.__RELAY_DEVTOOLS_HOOK__;
+  if (devToolsHook) {
+    devToolsHook.registerEnvironment(environment);
+  }
+}
+
+module.exports = registerEnvironmentWithDevTools;

package/util/withDuration.js.flow

@@ -0,0 +1,32 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const isPerformanceNowAvailable =
+  typeof window !== 'undefined' &&
+  typeof window?.performance?.now === 'function';
+
+function currentTimestamp(): number {
+  if (isPerformanceNowAvailable) {
+    return window.performance.now();
+  }
+  return Date.now();
+}
+
+function withDuration<T>(cb: () => T): [number, T] {
+  const startTime = currentTimestamp();
+  const result = cb();
+  return [currentTimestamp() - startTime, result];
+}
+
+module.exports = withDuration;

package/lib/store/RelayRecordSourceMapImpl.js

@@ -1,107 +0,0 @@
-/**
- * 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.
- *
- * 
- * @format
- */
-// flowlint ambiguous-object-type:error
-'use strict';
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
-
-var RelayRecordState = require('./RelayRecordState');
-
-var EXISTENT = RelayRecordState.EXISTENT,
-    NONEXISTENT = RelayRecordState.NONEXISTENT,
-    UNKNOWN = RelayRecordState.UNKNOWN;
-/**
- * An implementation of the `MutableRecordSource` interface (defined in
- * `RelayStoreTypes`) that holds all records in memory (JS Map).
- */
-
-var RelayMapRecordSourceMapImpl = /*#__PURE__*/function () {
-  function RelayMapRecordSourceMapImpl(records) {
-    var _this = this;
-
-    this._records = new Map();
-
-    if (records != null) {
-      Object.keys(records).forEach(function (key) {
-        _this._records.set(key, records[key]);
-      });
-    }
-  }
-
-  var _proto = RelayMapRecordSourceMapImpl.prototype;
-
-  _proto.clear = function clear() {
-    this._records = new Map();
-  };
-
-  _proto["delete"] = function _delete(dataID) {
-    this._records.set(dataID, null);
-  };
-
-  _proto.get = function get(dataID) {
-    return this._records.get(dataID);
-  };
-
-  _proto.getRecordIDs = function getRecordIDs() {
-    return Array.from(this._records.keys());
-  };
-
-  _proto.getStatus = function getStatus(dataID) {
-    if (!this._records.has(dataID)) {
-      return UNKNOWN;
-    }
-
-    return this._records.get(dataID) == null ? NONEXISTENT : EXISTENT;
-  };
-
-  _proto.has = function has(dataID) {
-    return this._records.has(dataID);
-  };
-
-  _proto.remove = function remove(dataID) {
-    this._records["delete"](dataID);
-  };
-
-  _proto.set = function set(dataID, record) {
-    this._records.set(dataID, record);
-  };
-
-  _proto.size = function size() {
-    return this._records.size;
-  };
-
-  _proto.toJSON = function toJSON() {
-    var obj = {};
-
-    var _iterator = (0, _createForOfIteratorHelper2["default"])(this._records),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _step.value,
-            key = _step$value[0],
-            value = _step$value[1];
-        obj[key] = value;
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-
-    return obj;
-  };
-
-  return RelayMapRecordSourceMapImpl;
-}();
-
-module.exports = RelayMapRecordSourceMapImpl;