relay-runtime 11.0.1 → 11.0.2

package/lib/util/RelayProfiler.js

@@ -10,25 +10,9 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-function emptyFunction() {}
-
-var aggregateHandlersByName = {
-  '*': []
-};
-var profileHandlersByName = {
-  '*': []
-};
-var NOT_INVOKED = {};
+var profileHandlersByName = {};
 var defaultProfiler = {
-  stop: emptyFunction
-};
-
-var shouldInstrument = function shouldInstrument(name) {
-  if (process.env.NODE_ENV !== "production") {
-    return true;
-  }
-
-  return name.charAt(0) !== '@';
+  stop: function stop() {}
 };
 /**
  * @public
@@ -57,152 +41,9 @@ var shouldInstrument = function shouldInstrument(name) {
  *       console.log(`Duration (${name})`, performance.now() - start);
  *     }
  *   });
- *
- * In order to reduce the impact on performance in production, instrumented
- * methods and profilers with names that begin with `@` will only be measured
- * if `__DEV__` is true. This should be used for very hot functions.
  */
 
-
 var RelayProfiler = {
-  /**
-   * Instruments methods on a class or object. This re-assigns the method in
-   * order to preserve function names in stack traces (which are detected by
-   * modern debuggers via heuristics). Example usage:
-   *
-   *   const RelayStore = { primeCache: function() {...} };
-   *   RelayProfiler.instrumentMethods(RelayStore, {
-   *     primeCache: 'RelayStore.primeCache'
-   *   });
-   *
-   *   RelayStore.primeCache.attachHandler(...);
-   *
-   * As a result, the methods will be replaced by wrappers that provide the
-   * `attachHandler` and `detachHandler` methods.
-   */
-  instrumentMethods: function instrumentMethods(object, names) {
-    for (var _key in names) {
-      if (names.hasOwnProperty(_key)) {
-        if (typeof object[_key] === 'function') {
-          object[_key] = RelayProfiler.instrument(names[_key], object[_key]);
-        }
-      }
-    }
-  },
-
-  /**
-   * Wraps the supplied function with one that provides the `attachHandler` and
-   * `detachHandler` methods. Example usage:
-   *
-   *   const printRelayQuery =
-   *     RelayProfiler.instrument('printRelayQuery', printRelayQuery);
-   *
-   *   printRelayQuery.attachHandler(...);
-   *
-   * NOTE: The instrumentation assumes that no handlers are attached or detached
-   * in the course of executing another handler.
-   */
-  instrument: function instrument(name, originalFunction) {
-    if (!shouldInstrument(name)) {
-      originalFunction.attachHandler = emptyFunction;
-      originalFunction.detachHandler = emptyFunction;
-      return originalFunction;
-    }
-
-    if (!aggregateHandlersByName.hasOwnProperty(name)) {
-      aggregateHandlersByName[name] = [];
-    }
-
-    var catchallHandlers = aggregateHandlersByName['*'];
-    var aggregateHandlers = aggregateHandlersByName[name];
-    var handlers = [];
-    var contexts = [];
-
-    var invokeHandlers = function invokeHandlers() {
-      var context = contexts[contexts.length - 1];
-
-      if (context[0]) {
-        context[0]--;
-        catchallHandlers[context[0]](name, invokeHandlers);
-      } else if (context[1]) {
-        context[1]--;
-        aggregateHandlers[context[1]](name, invokeHandlers);
-      } else if (context[2]) {
-        context[2]--;
-        handlers[context[2]](name, invokeHandlers);
-      } else {
-        context[5] = originalFunction.apply(context[3], context[4]);
-      }
-    };
-
-    var instrumentedCallback = function instrumentedCallback() {
-      var returnValue;
-
-      if (aggregateHandlers.length === 0 && handlers.length === 0 && catchallHandlers.length === 0) {
-        returnValue = originalFunction.apply(this, arguments);
-      } else {
-        contexts.push([catchallHandlers.length, aggregateHandlers.length, handlers.length, this, arguments, NOT_INVOKED]);
-        invokeHandlers();
-        var context = contexts.pop();
-        returnValue = context[5];
-
-        if (returnValue === NOT_INVOKED) {
-          throw new Error('RelayProfiler: Handler did not invoke original function.');
-        }
-      }
-
-      return returnValue;
-    };
-
-    instrumentedCallback.attachHandler = function (handler) {
-      handlers.push(handler);
-    };
-
-    instrumentedCallback.detachHandler = function (handler) {
-      removeFromArray(handlers, handler);
-    };
-
-    instrumentedCallback.displayName = '(instrumented ' + name + ')';
-    return instrumentedCallback;
-  },
-
-  /**
-   * Attaches a handler to all methods instrumented with the supplied name.
-   *
-   *   function createRenderer() {
-   *     return RelayProfiler.instrument('render', function() {...});
-   *   }
-   *   const renderA = createRenderer();
-   *   const renderB = createRenderer();
-   *
-   *   // Only profiles `renderA`.
-   *   renderA.attachHandler(...);
-   *
-   *   // Profiles both `renderA` and `renderB`.
-   *   RelayProfiler.attachAggregateHandler('render', ...);
-   *
-   */
-  attachAggregateHandler: function attachAggregateHandler(name, handler) {
-    if (shouldInstrument(name)) {
-      if (!aggregateHandlersByName.hasOwnProperty(name)) {
-        aggregateHandlersByName[name] = [];
-      }
-
-      aggregateHandlersByName[name].push(handler);
-    }
-  },
-
-  /**
-   * Detaches a handler attached via `attachAggregateHandler`.
-   */
-  detachAggregateHandler: function detachAggregateHandler(name, handler) {
-    if (shouldInstrument(name)) {
-      if (aggregateHandlersByName.hasOwnProperty(name)) {
-        removeFromArray(aggregateHandlersByName[name], handler);
-      }
-    }
-  },
-
   /**
    * Instruments profiling for arbitrarily asynchronous code by a name.
    *
@@ -217,27 +58,21 @@ var RelayProfiler = {
    * attached profile handlers will receive this as the second argument.
    */
   profile: function profile(name, state) {
-    var hasCatchAllHandlers = profileHandlersByName['*'].length > 0;
-    var hasNamedHandlers = profileHandlersByName.hasOwnProperty(name);
+    var handlers = profileHandlersByName[name];
 
-    if (hasNamedHandlers || hasCatchAllHandlers) {
-      var profileHandlers = hasNamedHandlers && hasCatchAllHandlers ? profileHandlersByName[name].concat(profileHandlersByName['*']) : hasNamedHandlers ? profileHandlersByName[name] : profileHandlersByName['*'];
-      var stopHandlers;
+    if (handlers && handlers.length > 0) {
+      var stopHandlers = [];
 
-      for (var ii = profileHandlers.length - 1; ii >= 0; ii--) {
-        var profileHandler = profileHandlers[ii];
-        var stopHandler = profileHandler(name, state);
-        stopHandlers = stopHandlers || [];
+      for (var ii = handlers.length - 1; ii >= 0; ii--) {
+        var stopHandler = handlers[ii](name, state);
         stopHandlers.unshift(stopHandler);
       }
 
       return {
         stop: function stop(error) {
-          if (stopHandlers) {
-            stopHandlers.forEach(function (stopHandler) {
-              return stopHandler(error);
-            });
-          }
+          stopHandlers.forEach(function (stopHandler) {
+            return stopHandler(error);
+          });
         }
       };
     }
@@ -246,27 +81,22 @@ var RelayProfiler = {
   },
 
   /**
-   * Attaches a handler to profiles with the supplied name. You can also
-   * attach to the special name '*' which is a catch all.
+   * Attaches a handler to profiles with the supplied name.
    */
   attachProfileHandler: function attachProfileHandler(name, handler) {
-    if (shouldInstrument(name)) {
-      if (!profileHandlersByName.hasOwnProperty(name)) {
-        profileHandlersByName[name] = [];
-      }
-
-      profileHandlersByName[name].push(handler);
+    if (!profileHandlersByName.hasOwnProperty(name)) {
+      profileHandlersByName[name] = [];
     }
+
+    profileHandlersByName[name].push(handler);
   },
 
   /**
    * Detaches a handler attached via `attachProfileHandler`.
    */
   detachProfileHandler: function detachProfileHandler(name, handler) {
-    if (shouldInstrument(name)) {
-      if (profileHandlersByName.hasOwnProperty(name)) {
-        removeFromArray(profileHandlersByName[name], handler);
-      }
+    if (profileHandlersByName.hasOwnProperty(name)) {
+      removeFromArray(profileHandlersByName[name], handler);
     }
   }
 };

package/lib/util/RelayReplaySubject.js

@@ -16,7 +16,7 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var RelayObservable = require('../network/RelayObservable');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 /**
  * An implementation of a `ReplaySubject` for Relay Observables.

package/lib/util/getRelayHandleKey.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('./RelayDefaultHandleKey'),
     DEFAULT_HANDLE_KEY = _require.DEFAULT_HANDLE_KEY;

package/lib/util/getRequestIdentifier.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var stableCopy = require('./stableCopy');
 

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

@@ -0,0 +1,27 @@
+/**
+ * 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;
+
+module.exports = {
+  getActorIdentifier(actorID: string): ActorIdentifier {
+    return (actorID: ActorIdentifier);
+  },
+
+  getDefaultActorIdentifier(): ActorIdentifier {
+    throw new Error('Not Implemented');
+  },
+};

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

@@ -0,0 +1,189 @@
+/**
+ * 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 RelayOperationTracker = require('../store/RelayOperationTracker');
+
+import type {GraphQLResponse, PayloadData} from '../network/RelayNetworkTypes';
+import type {INetwork} from '../network/RelayNetworkTypes';
+import type RelayObservable from '../network/RelayObservable';
+import type {
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  OperationDescriptor,
+  OperationAvailability,
+  Snapshot,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  StoreUpdater,
+  RequiredFieldLogger,
+  ExecuteMutationConfig,
+  LogFunction,
+  Store,
+  OperationTracker,
+} from '../store/RelayStoreTypes';
+import type {Disposable, RenderPolicy} from '../util/RelayRuntimeTypes';
+import type {ActorIdentifier} from './ActorIdentifier';
+import type {
+  IActorEnvironment,
+  IMultiActorEnvironment,
+} from './MultiActorEnvironmentTypes';
+
+function todo() {
+  throw new Error('Not implementd');
+}
+
+export type ActorSpecificEnvironmentConfig = $ReadOnly<{
+  actorIdentifier: ActorIdentifier,
+  logFn: LogFunction,
+  multiActorEnvironment: IMultiActorEnvironment,
+  network: INetwork,
+  requiredFieldLogger: RequiredFieldLogger,
+  store: Store,
+}>;
+
+class ActorSpecificEnvironment implements IActorEnvironment {
+  +options: mixed;
+  __log: LogFunction;
+  requiredFieldLogger: RequiredFieldLogger;
+  +_store: Store;
+  +_network: INetwork;
+  +_operationTracker: OperationTracker;
+
+  // Actor specific properties
+  +actorIdentifier: ActorIdentifier;
+  +multiActorEnvironment: IMultiActorEnvironment;
+
+  constructor(config: ActorSpecificEnvironmentConfig) {
+    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 = config.network;
+  }
+
+  UNSTABLE_getDefaultRenderPolicy(): RenderPolicy {
+    return todo();
+  }
+
+  applyMutation(optimisticConfig: OptimisticResponseConfig): Disposable {
+    return this.multiActorEnvironment.applyMutation(
+      this.actorIdentifier,
+      optimisticConfig,
+    );
+  }
+
+  applyUpdate(optimisticUpdate: OptimisticUpdateFunction): Disposable {
+    return this.multiActorEnvironment.applyUpdate(
+      this.actorIdentifier,
+      optimisticUpdate,
+    );
+  }
+
+  check(operation: OperationDescriptor): OperationAvailability {
+    return this.multiActorEnvironment.check(this.actorIdentifier, operation);
+  }
+
+  subscribe(
+    snapshot: Snapshot,
+    callback: (snapshot: Snapshot) => void,
+  ): Disposable {
+    return this.multiActorEnvironment.subscribe(
+      this.actorIdentifier,
+      snapshot,
+      callback,
+    );
+  }
+
+  retain(operation: OperationDescriptor): Disposable {
+    return this.multiActorEnvironment.retain(this.actorIdentifier, operation);
+  }
+
+  commitUpdate(updater: StoreUpdater): void {
+    return this.multiActorEnvironment.commitUpdate(
+      this.actorIdentifier,
+      updater,
+    );
+  }
+
+  /**
+   * Commit a payload to the environment using the given operation selector.
+   */
+  commitPayload(
+    operationDescriptor: OperationDescriptor,
+    payload: PayloadData,
+  ): void {
+    return this.multiActorEnvironment.commitPayload(
+      this.actorIdentifier,
+      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.actorIdentifier, selector);
+  }
+
+  execute(config: {
+    operation: OperationDescriptor,
+    updater?: ?SelectorStoreUpdater,
+  }): RelayObservable<GraphQLResponse> {
+    return this.multiActorEnvironment.execute(this.actorIdentifier, config);
+  }
+
+  executeMutation(
+    options: ExecuteMutationConfig,
+  ): RelayObservable<GraphQLResponse> {
+    return this.multiActorEnvironment.executeMutation(
+      this.actorIdentifier,
+      options,
+    );
+  }
+
+  executeWithSource(options: {
+    operation: OperationDescriptor,
+    source: RelayObservable<GraphQLResponse>,
+  }): RelayObservable<GraphQLResponse> {
+    return this.multiActorEnvironment.executeWithSource(
+      this.actorIdentifier,
+      options,
+    );
+  }
+
+  isRequestActive(requestIdentifier: string): boolean {
+    return this.multiActorEnvironment.isRequestActive(
+      this.actorIdentifier,
+      requestIdentifier,
+    );
+  }
+
+  isServer(): boolean {
+    return todo();
+  }
+}
+
+module.exports = ActorSpecificEnvironment;