relay-runtime 10.1.3 → 11.0.2

package/util/RelayProfiler.js.flow

@@ -12,25 +12,15 @@
 
 'use strict';
 
-type Handler = (name: string, callback: () => void) => void;
-type ProfileHandler = (name: string, state?: any) => (error?: Error) => void;
+type EventName = 'fetchRelayQuery';
+type ProfileHandler = (name: EventName, state?: any) => (error?: Error) => void;
 
-function emptyFunction() {}
+const profileHandlersByName: {|
+  [name: EventName]: Array<ProfileHandler>,
+|} = {};
 
-const aggregateHandlersByName: {[name: string]: Array<Handler>, ...} = {
-  '*': [],
-};
-const profileHandlersByName: {[name: string]: Array<ProfileHandler>, ...} = {
-  '*': [],
-};
-
-const NOT_INVOKED = {};
-const defaultProfiler = {stop: emptyFunction};
-const shouldInstrument = name => {
-  if (__DEV__) {
-    return true;
-  }
-  return name.charAt(0) !== '@';
+const defaultProfiler = {
+  stop() {},
 };
 
 /**
@@ -60,154 +50,8 @@ const 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.
  */
 const 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(
-    object: Function | Object,
-    names: {[key: string]: string, ...},
-  ): void {
-    for (const 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<T: Function>(name: string, originalFunction: T): T {
-    if (!shouldInstrument(name)) {
-      originalFunction.attachHandler = emptyFunction;
-      originalFunction.detachHandler = emptyFunction;
-      return originalFunction;
-    }
-    if (!aggregateHandlersByName.hasOwnProperty(name)) {
-      aggregateHandlersByName[name] = [];
-    }
-    const catchallHandlers = aggregateHandlersByName['*'];
-    const aggregateHandlers = aggregateHandlersByName[name];
-    const handlers: Array<Handler> = [];
-    const contexts: Array<[number, number, number, any, any, any]> = [];
-    const invokeHandlers = function() {
-      const 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]);
-      }
-    };
-    const instrumentedCallback = function() {
-      let 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();
-        const 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: Handler): void {
-      handlers.push(handler);
-    };
-    instrumentedCallback.detachHandler = function(handler: Handler): void {
-      removeFromArray(handlers, handler);
-    };
-    instrumentedCallback.displayName = '(instrumented ' + name + ')';
-    return (instrumentedCallback: any);
-  },
-
-  /**
-   * 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(name: string, handler: Handler): void {
-    if (shouldInstrument(name)) {
-      if (!aggregateHandlersByName.hasOwnProperty(name)) {
-        aggregateHandlersByName[name] = [];
-      }
-      aggregateHandlersByName[name].push(handler);
-    }
-  },
-
-  /**
-   * Detaches a handler attached via `attachAggregateHandler`.
-   */
-  detachAggregateHandler(name: string, handler: Handler): void {
-    if (shouldInstrument(name)) {
-      if (aggregateHandlersByName.hasOwnProperty(name)) {
-        removeFromArray(aggregateHandlersByName[name], handler);
-      }
-    }
-  },
-
   /**
    * Instruments profiling for arbitrarily asynchronous code by a name.
    *
@@ -221,28 +65,17 @@ const RelayProfiler = {
    * Arbitrary state can also be passed into `profile` as a second argument. The
    * attached profile handlers will receive this as the second argument.
    */
-  profile(name: string, state?: any): {stop: (error?: Error) => void, ...} {
-    const hasCatchAllHandlers = profileHandlersByName['*'].length > 0;
-    const hasNamedHandlers = profileHandlersByName.hasOwnProperty(name);
-    if (hasNamedHandlers || hasCatchAllHandlers) {
-      const profileHandlers =
-        hasNamedHandlers && hasCatchAllHandlers
-          ? profileHandlersByName[name].concat(profileHandlersByName['*'])
-          : hasNamedHandlers
-          ? profileHandlersByName[name]
-          : profileHandlersByName['*'];
-      let stopHandlers;
-      for (let ii = profileHandlers.length - 1; ii >= 0; ii--) {
-        const profileHandler = profileHandlers[ii];
-        const stopHandler = profileHandler(name, state);
-        stopHandlers = stopHandlers || [];
+  profile(name: EventName, state?: any): {stop: (error?: Error) => void, ...} {
+    const handlers = profileHandlersByName[name];
+    if (handlers && handlers.length > 0) {
+      const stopHandlers = [];
+      for (let ii = handlers.length - 1; ii >= 0; ii--) {
+        const stopHandler = handlers[ii](name, state);
         stopHandlers.unshift(stopHandler);
       }
       return {
         stop(error?: Error): void {
-          if (stopHandlers) {
-            stopHandlers.forEach(stopHandler => stopHandler(error));
-          }
+          stopHandlers.forEach(stopHandler => stopHandler(error));
         },
       };
     }
@@ -250,26 +83,21 @@ const 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(name: string, handler: ProfileHandler): void {
-    if (shouldInstrument(name)) {
-      if (!profileHandlersByName.hasOwnProperty(name)) {
-        profileHandlersByName[name] = [];
-      }
-      profileHandlersByName[name].push(handler);
+  attachProfileHandler(name: EventName, handler: ProfileHandler): void {
+    if (!profileHandlersByName.hasOwnProperty(name)) {
+      profileHandlersByName[name] = [];
     }
+    profileHandlersByName[name].push(handler);
   },
 
   /**
    * Detaches a handler attached via `attachProfileHandler`.
    */
-  detachProfileHandler(name: string, handler: ProfileHandler): void {
-    if (shouldInstrument(name)) {
-      if (profileHandlersByName.hasOwnProperty(name)) {
-        removeFromArray(profileHandlersByName[name], handler);
-      }
+  detachProfileHandler(name: EventName, handler: ProfileHandler): void {
+    if (profileHandlersByName.hasOwnProperty(name)) {
+      removeFromArray(profileHandlersByName[name], handler);
     }
   },
 };

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,13 +58,11 @@ export type CacheConfig = {|
   force?: ?boolean,
   poll?: ?number,
   liveConfigId?: ?string,
+  onSubscribe?: () => void,
   metadata?: {[key: string]: mixed, ...},
   transactionId?: ?string,
 |};
 
-/**
- * Experimental
- */
 export type FetchQueryFetchPolicy = 'store-or-network' | 'network-only';
 export type FetchPolicy =
   | FetchQueryFetchPolicy

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/isEmptyObject.js.flow

@@ -13,7 +13,7 @@
 
 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;