relay-runtime 11.0.1 → 13.0.0-rc.1

package/lib/util/getRequestIdentifier.js

@@ -10,10 +10,10 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
-
 var stableCopy = require('./stableCopy');
 
+var invariant = require('invariant');
+
 /**
  * Returns a stable identifier for the given pair of `RequestParameters` +
  * variables.

package/lib/util/getValueAtPath.js

@@ -0,0 +1,51 @@
+/**
+ * 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
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var invariant = require('invariant');
+
+function getValueAtPath(data, path) {
+  var result = data;
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(path),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+
+      if (result == null) {
+        return null;
+      }
+
+      if (typeof key === 'number') {
+        !Array.isArray(result) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: Expected an array when extracting value at path. ' + "If you're seeing this, this is likely a bug in Relay.") : invariant(false) : void 0;
+        result = result[key];
+      } else {
+        !(typeof result === 'object' && !Array.isArray(result)) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: Expected an object when extracting value at path. ' + "If you're seeing this, this is likely a bug in Relay.") : invariant(false) : void 0;
+        result = result[key];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return result;
+}
+
+module.exports = getValueAtPath;

package/lib/util/isEmptyObject.js

@@ -8,7 +8,7 @@
  * @format
  * @emails oncall+relay
  */
-'use strict';
+'use strict'; // $FlowFixMe[method-unbinding] added when improving typing for this parameters
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 

package/lib/util/registerEnvironmentWithDevTools.js

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

package/lib/util/withDuration.js

@@ -0,0 +1,31 @@
+/**
+ * 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 _window, _window$performance;
+
+var isPerformanceNowAvailable = typeof window !== 'undefined' && typeof ((_window = window) === null || _window === void 0 ? void 0 : (_window$performance = _window.performance) === null || _window$performance === void 0 ? void 0 : _window$performance.now) === 'function';
+
+function currentTimestamp() {
+  if (isPerformanceNowAvailable) {
+    return window.performance.now();
+  }
+
+  return Date.now();
+}
+
+function withDuration(cb) {
+  var startTime = currentTimestamp();
+  var result = cb();
+  return [currentTimestamp() - startTime, result];
+}
+
+module.exports = withDuration;

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

@@ -0,0 +1,43 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict';
+
+/**
+ * A unique identifier of the current actor.
+ */
+export opaque type ActorIdentifier = string;
+
+const invariant = require('invariant');
+
+const INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE: ActorIdentifier =
+  'INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE';
+
+function assertInternalActorIndentifier(
+  actorIdentifier: ActorIdentifier,
+): void {
+  invariant(
+    actorIdentifier === INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+    'Expected to use only internal version of the `actorIdentifier`. "%s" was provided.',
+    actorIdentifier,
+  );
+}
+
+module.exports = {
+  assertInternalActorIndentifier,
+  getActorIdentifier(actorID: string): ActorIdentifier {
+    return (actorID: ActorIdentifier);
+  },
+  getDefaultActorIdentifier(): ActorIdentifier {
+    throw new Error('Not Implemented');
+  },
+  INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+};

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

@@ -0,0 +1,225 @@
+/**
+ * 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 {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
+import type {GraphQLResponse, PayloadData} from '../network/RelayNetworkTypes';
+import type {INetwork} from '../network/RelayNetworkTypes';
+import type RelayObservable from '../network/RelayObservable';
+import type {
+  ExecuteMutationConfig,
+  LogFunction,
+  MutationParameters,
+  OperationAvailability,
+  OperationDescriptor,
+  OperationTracker,
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  RequiredFieldLogger,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Snapshot,
+  Store,
+  StoreUpdater,
+} from '../store/RelayStoreTypes';
+import type {Disposable, RenderPolicy} from '../util/RelayRuntimeTypes';
+import type {ActorIdentifier} from './ActorIdentifier';
+import type {
+  IActorEnvironment,
+  IMultiActorEnvironment,
+} from './MultiActorEnvironmentTypes';
+
+const wrapNetworkWithLogObserver = require('../network/wrapNetworkWithLogObserver');
+const defaultGetDataID = require('../store/defaultGetDataID');
+const RelayOperationTracker = require('../store/RelayOperationTracker');
+const RelayPublishQueue = require('../store/RelayPublishQueue');
+const registerEnvironmentWithDevTools = require('../util/registerEnvironmentWithDevTools');
+
+export type ActorSpecificEnvironmentConfig = $ReadOnly<{
+  actorIdentifier: ActorIdentifier,
+  configName: ?string,
+  defaultRenderPolicy: RenderPolicy,
+  handlerProvider: HandlerProvider,
+  logFn: LogFunction,
+  multiActorEnvironment: IMultiActorEnvironment,
+  network: INetwork,
+  requiredFieldLogger: RequiredFieldLogger,
+  store: Store,
+}>;
+
+class ActorSpecificEnvironment implements IActorEnvironment {
+  __log: LogFunction;
+  +_defaultRenderPolicy: RenderPolicy;
+  +_network: INetwork;
+  +_operationTracker: OperationTracker;
+  +_publishQueue: RelayPublishQueue;
+  +_store: Store;
+  +actorIdentifier: ActorIdentifier;
+  +configName: ?string;
+  +multiActorEnvironment: IMultiActorEnvironment;
+  +options: mixed;
+  requiredFieldLogger: RequiredFieldLogger;
+
+  constructor(config: ActorSpecificEnvironmentConfig) {
+    this.configName = config.configName;
+    this.actorIdentifier = config.actorIdentifier;
+    this.multiActorEnvironment = config.multiActorEnvironment;
+
+    this.__log = config.logFn;
+    this.requiredFieldLogger = config.requiredFieldLogger;
+    this._operationTracker = new RelayOperationTracker();
+    this._store = config.store;
+    this._network = wrapNetworkWithLogObserver(this, config.network);
+    this._publishQueue = new RelayPublishQueue(
+      config.store,
+      config.handlerProvider,
+      defaultGetDataID,
+    );
+    this._defaultRenderPolicy = config.defaultRenderPolicy;
+    // TODO:T92305692 Remove `options` in favor of directly using `actorIdentifier` on the environment
+    this.options = {
+      actorID: this.actorIdentifier,
+    };
+
+    // We need to add this here to pass `isRelayModernEnvironment` check
+    // $FlowFixMe[prop-missing]
+    this['@@RelayModernEnvironment'] = true;
+
+    if (__DEV__) {
+      const {inspect} = require('../store/StoreInspector');
+      (this: $FlowFixMe).DEBUG_inspect = (dataID: ?string) =>
+        inspect(this, dataID);
+    }
+
+    // Register this Relay Environment with Relay DevTools if it exists.
+    // Note: this must always be the last step in the constructor.
+    registerEnvironmentWithDevTools(this);
+  }
+
+  getPublishQueue(): RelayPublishQueue {
+    return this._publishQueue;
+  }
+
+  UNSTABLE_getDefaultRenderPolicy(): RenderPolicy {
+    return this._defaultRenderPolicy;
+  }
+
+  applyMutation<TMutation: MutationParameters>(
+    optimisticConfig: OptimisticResponseConfig<TMutation>,
+  ): Disposable {
+    return this.multiActorEnvironment.applyMutation(this, optimisticConfig);
+  }
+
+  applyUpdate(optimisticUpdate: OptimisticUpdateFunction): Disposable {
+    return this.multiActorEnvironment.applyUpdate(this, optimisticUpdate);
+  }
+
+  revertUpdate(optimisticUpdate: OptimisticUpdateFunction): void {
+    return this.multiActorEnvironment.revertUpdate(this, optimisticUpdate);
+  }
+
+  replaceUpdate(
+    optimisticUpdate: OptimisticUpdateFunction,
+    replacementUpdate: OptimisticUpdateFunction,
+  ): void {
+    return this.multiActorEnvironment.replaceUpdate(
+      this,
+      optimisticUpdate,
+      replacementUpdate,
+    );
+  }
+
+  check(operation: OperationDescriptor): OperationAvailability {
+    return this.multiActorEnvironment.check(this, operation);
+  }
+
+  subscribe(
+    snapshot: Snapshot,
+    callback: (snapshot: Snapshot) => void,
+  ): Disposable {
+    return this.multiActorEnvironment.subscribe(this, snapshot, callback);
+  }
+
+  retain(operation: OperationDescriptor): Disposable {
+    return this.multiActorEnvironment.retain(this, operation);
+  }
+
+  commitUpdate(updater: StoreUpdater): void {
+    return this.multiActorEnvironment.commitUpdate(this, updater);
+  }
+
+  /**
+   * Commit a payload to the environment using the given operation selector.
+   */
+  commitPayload(
+    operationDescriptor: OperationDescriptor,
+    payload: PayloadData,
+  ): void {
+    return this.multiActorEnvironment.commitPayload(
+      this,
+      operationDescriptor,
+      payload,
+    );
+  }
+
+  getNetwork(): INetwork {
+    return this._network;
+  }
+
+  getStore(): Store {
+    return this._store;
+  }
+
+  getOperationTracker(): OperationTracker {
+    return this._operationTracker;
+  }
+
+  lookup(selector: SingularReaderSelector): Snapshot {
+    return this.multiActorEnvironment.lookup(this, selector);
+  }
+
+  execute(config: {
+    operation: OperationDescriptor,
+  }): RelayObservable<GraphQLResponse> {
+    return this.multiActorEnvironment.execute(this, config);
+  }
+
+  executeSubscription<TMutation: MutationParameters>(config: {
+    operation: OperationDescriptor,
+    updater?: ?SelectorStoreUpdater<TMutation['response']>,
+  }): RelayObservable<GraphQLResponse> {
+    return this.multiActorEnvironment.executeSubscription(this, config);
+  }
+
+  executeMutation<TMutation: MutationParameters>(
+    options: ExecuteMutationConfig<TMutation>,
+  ): RelayObservable<GraphQLResponse> {
+    return this.multiActorEnvironment.executeMutation(this, options);
+  }
+
+  executeWithSource(options: {
+    operation: OperationDescriptor,
+    source: RelayObservable<GraphQLResponse>,
+  }): RelayObservable<GraphQLResponse> {
+    return this.multiActorEnvironment.executeWithSource(this, options);
+  }
+
+  isRequestActive(requestIdentifier: string): boolean {
+    return this.multiActorEnvironment.isRequestActive(this, requestIdentifier);
+  }
+
+  isServer(): boolean {
+    return this.multiActorEnvironment.isServer();
+  }
+}
+
+module.exports = ActorSpecificEnvironment;

package/multi-actor-environment/ActorUtils.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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const ACTOR_IDENTIFIER_FIELD_NAME = 'actor_key';
+
+import type {ActorIdentifier} from './ActorIdentifier';
+
+const {getActorIdentifier} = require('./ActorIdentifier');
+
+function getActorIdentifierFromPayload(payload: mixed): ?ActorIdentifier {
+  if (
+    payload != null &&
+    typeof payload === 'object' &&
+    typeof payload[ACTOR_IDENTIFIER_FIELD_NAME] === 'string'
+  ) {
+    return getActorIdentifier(payload[ACTOR_IDENTIFIER_FIELD_NAME]);
+  }
+}
+
+module.exports = {
+  ACTOR_IDENTIFIER_FIELD_NAME,
+  getActorIdentifierFromPayload,
+};