relay-runtime 11.0.2 → 12.0.0

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

@@ -16,12 +16,28 @@
  */
 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

@@ -12,7 +12,13 @@
 'use strict';
 
 const RelayOperationTracker = require('../store/RelayOperationTracker');
+const RelayPublishQueue = require('../store/RelayPublishQueue');
 
+const defaultGetDataID = require('../store/defaultGetDataID');
+const registerEnvironmentWithDevTools = require('../util/registerEnvironmentWithDevTools');
+const wrapNetworkWithLogObserver = require('../network/wrapNetworkWithLogObserver');
+
+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';
@@ -38,12 +44,11 @@ import type {
   IMultiActorEnvironment,
 } from './MultiActorEnvironmentTypes';
 
-function todo() {
-  throw new Error('Not implementd');
-}
-
 export type ActorSpecificEnvironmentConfig = $ReadOnly<{
   actorIdentifier: ActorIdentifier,
+  configName: ?string,
+  defaultRenderPolicy: RenderPolicy,
+  handlerProvider: HandlerProvider,
   logFn: LogFunction,
   multiActorEnvironment: IMultiActorEnvironment,
   network: INetwork,
@@ -52,18 +57,20 @@ export type ActorSpecificEnvironmentConfig = $ReadOnly<{
 }>;
 
 class ActorSpecificEnvironment implements IActorEnvironment {
-  +options: mixed;
   __log: LogFunction;
-  requiredFieldLogger: RequiredFieldLogger;
-  +_store: Store;
+  +_defaultRenderPolicy: RenderPolicy;
   +_network: INetwork;
   +_operationTracker: OperationTracker;
-
-  // Actor specific properties
+  +_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;
 
@@ -71,51 +78,81 @@ class ActorSpecificEnvironment implements IActorEnvironment {
     this.requiredFieldLogger = config.requiredFieldLogger;
     this._operationTracker = new RelayOperationTracker();
     this._store = config.store;
-    this._network = config.network;
+    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 todo();
+    return this._defaultRenderPolicy;
   }
 
   applyMutation(optimisticConfig: OptimisticResponseConfig): Disposable {
-    return this.multiActorEnvironment.applyMutation(
-      this.actorIdentifier,
-      optimisticConfig,
-    );
+    return this.multiActorEnvironment.applyMutation(this, optimisticConfig);
   }
 
   applyUpdate(optimisticUpdate: OptimisticUpdateFunction): Disposable {
-    return this.multiActorEnvironment.applyUpdate(
-      this.actorIdentifier,
+    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.actorIdentifier, operation);
+    return this.multiActorEnvironment.check(this, operation);
   }
 
   subscribe(
     snapshot: Snapshot,
     callback: (snapshot: Snapshot) => void,
   ): Disposable {
-    return this.multiActorEnvironment.subscribe(
-      this.actorIdentifier,
-      snapshot,
-      callback,
-    );
+    return this.multiActorEnvironment.subscribe(this, snapshot, callback);
   }
 
   retain(operation: OperationDescriptor): Disposable {
-    return this.multiActorEnvironment.retain(this.actorIdentifier, operation);
+    return this.multiActorEnvironment.retain(this, operation);
   }
 
   commitUpdate(updater: StoreUpdater): void {
-    return this.multiActorEnvironment.commitUpdate(
-      this.actorIdentifier,
-      updater,
-    );
+    return this.multiActorEnvironment.commitUpdate(this, updater);
   }
 
   /**
@@ -126,7 +163,7 @@ class ActorSpecificEnvironment implements IActorEnvironment {
     payload: PayloadData,
   ): void {
     return this.multiActorEnvironment.commitPayload(
-      this.actorIdentifier,
+      this,
       operationDescriptor,
       payload,
     );
@@ -145,44 +182,35 @@ class ActorSpecificEnvironment implements IActorEnvironment {
   }
 
   lookup(selector: SingularReaderSelector): Snapshot {
-    return this.multiActorEnvironment.lookup(this.actorIdentifier, selector);
+    return this.multiActorEnvironment.lookup(this, selector);
   }
 
   execute(config: {
     operation: OperationDescriptor,
     updater?: ?SelectorStoreUpdater,
   }): RelayObservable<GraphQLResponse> {
-    return this.multiActorEnvironment.execute(this.actorIdentifier, config);
+    return this.multiActorEnvironment.execute(this, config);
   }
 
   executeMutation(
     options: ExecuteMutationConfig,
   ): RelayObservable<GraphQLResponse> {
-    return this.multiActorEnvironment.executeMutation(
-      this.actorIdentifier,
-      options,
-    );
+    return this.multiActorEnvironment.executeMutation(this, options);
   }
 
   executeWithSource(options: {
     operation: OperationDescriptor,
     source: RelayObservable<GraphQLResponse>,
   }): RelayObservable<GraphQLResponse> {
-    return this.multiActorEnvironment.executeWithSource(
-      this.actorIdentifier,
-      options,
-    );
+    return this.multiActorEnvironment.executeWithSource(this, options);
   }
 
   isRequestActive(requestIdentifier: string): boolean {
-    return this.multiActorEnvironment.isRequestActive(
-      this.actorIdentifier,
-      requestIdentifier,
-    );
+    return this.multiActorEnvironment.isRequestActive(this, requestIdentifier);
   }
 
   isServer(): boolean {
-    return todo();
+    return this.multiActorEnvironment.isServer();
   }
 }
 

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';
+
+const {getActorIdentifier} = require('./ActorIdentifier');
+
+import type {ActorIdentifier} from './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,
+};