relay-runtime 11.0.0-rc.0 → 12.0.0

package/store/ResolverFragments.js.flow

@@ -0,0 +1,128 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+const {getFragment} = require('../query/GraphQLTag');
+const {getSelector} = require('./RelayModernSelector');
+
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {
+  FragmentReference,
+  SingularReaderSelector,
+} from './RelayStoreTypes';
+
+// When we call the user-supplied resolver function, it will in turn call
+// `readFragment`, but that's a global function -- it needs information
+// about what resolver is being executed, which is supplied by putting the
+// info on this stack before we call the resolver function.
+type ResolverContext = {|
+  getDataForResolverFragment: (
+    SingularReaderSelector,
+    FragmentReference,
+  ) => mixed,
+|};
+const contextStack: Array<ResolverContext> = [];
+
+function withResolverContext<T>(context: ResolverContext, cb: () => T): T {
+  contextStack.push(context);
+  try {
+    return cb();
+  } finally {
+    contextStack.pop();
+  }
+}
+
+// NOTE: these declarations are copied from 'useFragment'; it would be good
+// to figure out how to share the same type signature between the two functions.
+// The declarations ensure that the type of the returned data is:
+//   - non-nullable if the provided ref type is non-nullable
+//   - nullable if the provided ref type is nullable
+//   - array of non-nullable if the privoided ref type is an array of
+//     non-nullable refs
+//   - array of nullable if the privoided ref type is an array of nullable refs
+
+declare function readFragment<
+  TKey: {+$data?: mixed, +$fragmentRefs: FragmentReference, ...},
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<<TFragmentData>({+$data?: TFragmentData, ...}) => TFragmentData, TKey>;
+
+declare function readFragment<
+  TKey: ?{+$data?: mixed, +$fragmentRefs: FragmentReference, ...},
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<
+  <TFragmentData>(?{+$data?: TFragmentData, ...}) => ?TFragmentData,
+  TKey,
+>;
+
+declare function readFragment<
+  TKey: $ReadOnlyArray<{
+    +$data?: mixed,
+    +$fragmentRefs: FragmentReference,
+    ...
+  }>,
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<
+  <TFragmentData>(
+    $ReadOnlyArray<{+$data?: TFragmentData, ...}>,
+  ) => TFragmentData,
+  TKey,
+>;
+
+declare function readFragment<
+  TKey: ?$ReadOnlyArray<{
+    +$data?: mixed,
+    +$fragmentRefs: FragmentReference,
+    ...
+  }>,
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<
+  <TFragmentData>(
+    ?$ReadOnlyArray<{+$data?: TFragmentData, ...}>,
+  ) => ?TFragmentData,
+  TKey,
+>;
+
+function readFragment(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: FragmentReference,
+): mixed {
+  if (!contextStack.length) {
+    throw new Error(
+      'readFragment should be called only from within a Relay Resolver function.',
+    );
+  }
+  const context = contextStack[contextStack.length - 1];
+  const fragmentNode = getFragment(fragmentInput);
+  const fragmentSelector = getSelector(fragmentNode, fragmentRef);
+  invariant(
+    fragmentSelector != null,
+    `Expected a selector for the fragment of the resolver ${fragmentNode.name}, but got null.`,
+  );
+  invariant(
+    fragmentSelector.kind === 'SingularReaderSelector',
+    `Expected a singular reader selector for the fragment of the resolver ${fragmentNode.name}, but it was plural.`,
+  );
+  return context.getDataForResolverFragment(fragmentSelector, fragmentRef);
+}
+
+module.exports = {readFragment, withResolverContext};

package/store/createRelayContext.js.flow

@@ -38,7 +38,7 @@ function createRelayContext(react: React): React$Context<RelayContext | null> {
   }
   invariant(
     react === firstReact,
-    '[createRelayContext]: You passing a different instance of React',
+    '[createRelayContext]: You are passing a different instance of React',
     react.version,
   );
   return relayContext;

package/store/defaultGetDataID.js.flow

@@ -15,12 +15,14 @@
 const {VIEWER_ID, VIEWER_TYPE} = require('./ViewerPattern');
 
 function defaultGetDataID(
-  fieldValue: {[string]: mixed, ...},
+  fieldValue: interface {[string]: mixed},
   typeName: string,
 ): mixed {
   if (typeName === VIEWER_TYPE) {
+    // $FlowFixMe[prop-missing]
     return fieldValue.id == null ? VIEWER_ID : fieldValue.id;
   }
+  // $FlowFixMe[prop-missing]
   return fieldValue.id;
 }
 

package/subscription/requestSubscription.js.flow

@@ -13,6 +13,7 @@
 'use strict';
 
 const RelayDeclarativeMutationConfig = require('../mutations/RelayDeclarativeMutationConfig');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 const warning = require('warning');
 
@@ -20,6 +21,7 @@ const {getRequest} = require('../query/GraphQLTag');
 const {
   createOperationDescriptor,
 } = require('../store/RelayModernOperationDescriptor');
+const {createReaderSelector} = require('../store/RelayModernSelector');
 
 import type {DeclarativeMutationConfig} from '../mutations/RelayDeclarativeMutationConfig';
 import type {GraphQLTaggedNode} from '../query/GraphQLTag';
@@ -33,7 +35,24 @@ import type {
   Variables,
 } from '../util/RelayRuntimeTypes';
 
-export type GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
+export type SubscriptionParameters = {|
+  +response: {...},
+  +variables: interface {},
+  +rawResponse?: {...},
+|};
+
+export type GraphQLSubscriptionConfig<T: SubscriptionParameters> = {|
+  configs?: Array<DeclarativeMutationConfig>,
+  cacheConfig?: CacheConfig,
+  subscription: GraphQLTaggedNode,
+  variables: $ElementType<T, 'variables'>,
+  onCompleted?: ?() => void,
+  onError?: ?(error: Error) => void,
+  onNext?: ?(response: ?$ElementType<T, 'response'>) => void,
+  updater?: ?SelectorStoreUpdater,
+|};
+
+export type DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
   configs?: Array<DeclarativeMutationConfig>,
   cacheConfig?: CacheConfig,
   subscription: GraphQLTaggedNode,
@@ -46,7 +65,7 @@ export type GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
 
 function requestSubscription<TSubscriptionPayload>(
   environment: IEnvironment,
-  config: GraphQLSubscriptionConfig<TSubscriptionPayload>,
+  config: DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload>,
 ): Disposable {
   const subscription = getRequest(config.subscription);
   if (subscription.params.operationKind !== 'subscription') {
@@ -85,13 +104,29 @@ function requestSubscription<TSubscriptionPayload>(
       operation,
       updater,
     })
-    .map(() => {
-      const data = environment.lookup(operation.fragment).data;
-      // $FlowFixMe[incompatible-cast]
-      return (data: TSubscriptionPayload);
-    })
     .subscribe({
-      next: onNext,
+      next: responses => {
+        if (onNext != null) {
+          let selector = operation.fragment;
+          let nextID;
+          if (Array.isArray(responses)) {
+            nextID = responses[0]?.extensions?.__relay_subscription_root_id;
+          } else {
+            nextID = responses.extensions?.__relay_subscription_root_id;
+          }
+          if (typeof nextID === 'string') {
+            selector = createReaderSelector(
+              selector.node,
+              nextID,
+              selector.variables,
+              selector.owner,
+            );
+          }
+          const data = environment.lookup(selector).data;
+          // $FlowFixMe[incompatible-cast]
+          onNext((data: TSubscriptionPayload));
+        }
+      },
       error: onError,
       complete: onCompleted,
     });

package/util/NormalizationNode.js.flow

@@ -87,7 +87,7 @@ export type NormalizationInlineFragment = {|
 
 export type NormalizationFragmentSpread = {|
   +kind: 'FragmentSpread',
-  +fragment: NormalizationNode,
+  +fragment: NormalizationSplitOperation,
   +args: ?$ReadOnlyArray<NormalizationArgument>,
 |};
 
@@ -102,7 +102,13 @@ export type NormalizationLinkedField = {|
   +selections: $ReadOnlyArray<NormalizationSelection>,
 |};
 
+export type NormalizationActorChange = {|
+  +kind: 'ActorChange',
+  +linkedField: NormalizationLinkedField,
+|};
+
 export type NormalizationModuleImport = {|
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
   +kind: 'ModuleImport',
   +documentName: string,
   +fragmentPropName: string,
@@ -154,6 +160,12 @@ export type NormalizationFlightField = {|
   +storageKey: ?string,
 |};
 
+export type NormalizationClientComponent = {|
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +kind: 'ClientComponent',
+  +fragment: NormalizationNode,
+|};
+
 export type NormalizationTypeDiscriminator = {|
   +kind: 'TypeDiscriminator',
   +abstractKey: string,
@@ -161,6 +173,7 @@ export type NormalizationTypeDiscriminator = {|
 
 export type NormalizationSelection =
   | NormalizationCondition
+  | NormalizationClientComponent
   | NormalizationClientExtension
   | NormalizationDefer
   | NormalizationField
@@ -170,9 +183,11 @@ export type NormalizationSelection =
   | NormalizationInlineFragment
   | NormalizationModuleImport
   | NormalizationStream
+  | NormalizationActorChange
   | NormalizationTypeDiscriminator;
 
 export type NormalizationSplitOperation = {|
+  +argumentDefinitions?: $ReadOnlyArray<NormalizationLocalArgumentDefinition>,
   +kind: 'SplitOperation',
   +name: string,
   +metadata: ?{+[key: string]: mixed, ...},
@@ -183,8 +198,6 @@ export type NormalizationStream = {|
   +if: string | null,
   +kind: 'Stream',
   +label: string,
-  +useCustomizedBatch: string | null,
-  +metadata: ?{+[key: string]: mixed, ...},
   +selections: $ReadOnlyArray<NormalizationSelection>,
 |};
 

package/util/ReaderNode.js.flow

@@ -108,7 +108,10 @@ export type ReaderClientExtension = {|
   +selections: $ReadOnlyArray<ReaderSelection>,
 |};
 
-export type ReaderField = ReaderScalarField | ReaderLinkedField;
+export type ReaderField =
+  | ReaderScalarField
+  | ReaderLinkedField
+  | ReaderRelayResolver;
 
 export type ReaderRootArgument = {|
   +kind: 'RootArgument',
@@ -133,7 +136,17 @@ export type ReaderLinkedField = {|
   +selections: $ReadOnlyArray<ReaderSelection>,
 |};
 
+export type ReaderActorChange = {|
+  +kind: 'ActorChange',
+  +alias: ?string,
+  +name: string,
+  +storageKey: ?string,
+  +args: ?$ReadOnlyArray<ReaderArgument>,
+  +fragmentSpread: ReaderFragmentSpread,
+|};
+
 export type ReaderModuleImport = {|
+  +args?: ?$ReadOnlyArray<ReaderArgument>,
   +kind: 'ModuleImport',
   +documentName: string,
   +fragmentPropName: string,
@@ -206,18 +219,32 @@ export type ReaderRequiredField = {|
   +path: string,
 |};
 
+export type ReaderRelayResolver = {|
+  +kind: 'RelayResolver',
+  +alias: ?string,
+  +name: string,
+  +fragment: ReaderFragmentSpread,
+  +resolverModule: (rootKey: {
+    +$data?: any, // flowlint-line unclear-type:off
+    +$fragmentRefs: any, // flowlint-line unclear-type:off
+    ...
+  }) => mixed,
+|};
+
 export type ReaderSelection =
   | ReaderCondition
   | ReaderClientExtension
   | ReaderDefer
   | ReaderField
+  | ReaderActorChange
   | ReaderFlightField
   | ReaderFragmentSpread
   | ReaderInlineDataFragmentSpread
   | ReaderInlineFragment
   | ReaderModuleImport
   | ReaderStream
-  | ReaderRequiredField;
+  | ReaderRequiredField
+  | ReaderRelayResolver;
 
 export type ReaderVariableArgument = {|
   +kind: 'Variable',

package/util/RelayConcreteNode.js.flow

@@ -67,7 +67,9 @@ export type GeneratedNode =
   | NormalizationSplitOperation;
 
 const RelayConcreteNode = {
+  ACTOR_CHANGE: 'ActorChange',
   CONDITION: 'Condition',
+  CLIENT_COMPONENT: 'ClientComponent',
   CLIENT_EXTENSION: 'ClientExtension',
   DEFER: 'Defer',
   CONNECTION: 'Connection',
@@ -83,6 +85,7 @@ const RelayConcreteNode = {
   LIST_VALUE: 'ListValue',
   LOCAL_ARGUMENT: 'LocalArgument',
   MODULE_IMPORT: 'ModuleImport',
+  RELAY_RESOLVER: 'RelayResolver',
   REQUIRED_FIELD: 'RequiredField',
   OBJECT_VALUE: 'ObjectValue',
   OPERATION: 'Operation',

package/util/RelayFeatureFlags.js.flow

@@ -12,34 +12,38 @@
 
 'use strict';
 
+import type {Disposable} from '../util/RelayRuntimeTypes';
+
 type FeatureFlags = {|
   ENABLE_VARIABLE_CONNECTION_KEY: boolean,
   ENABLE_PARTIAL_RENDERING_DEFAULT: boolean,
-  ENABLE_RELAY_CONTAINERS_SUSPENSE: boolean,
-  ENABLE_PRECISE_TYPE_REFINEMENT: boolean,
   ENABLE_REACT_FLIGHT_COMPONENT_FIELD: boolean,
   ENABLE_REQUIRED_DIRECTIVES: boolean | string,
+  ENABLE_RELAY_RESOLVERS: boolean,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean,
-  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: boolean,
   ENABLE_LOAD_QUERY_REQUEST_DEDUPING: boolean,
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: boolean,
   ENABLE_NOTIFY_SUBSCRIPTION: boolean,
+  BATCH_ASYNC_MODULE_UPDATES_FN: ?(() => void) => Disposable,
+  ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT: boolean,
+  ENABLE_QUERY_RENDERER_OFFSCREEN_SUPPORT: boolean,
 |};
 
 const RelayFeatureFlags: FeatureFlags = {
   ENABLE_VARIABLE_CONNECTION_KEY: false,
   ENABLE_PARTIAL_RENDERING_DEFAULT: true,
-  ENABLE_RELAY_CONTAINERS_SUSPENSE: true,
-  ENABLE_PRECISE_TYPE_REFINEMENT: false,
   ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,
   ENABLE_REQUIRED_DIRECTIVES: false,
+  ENABLE_RELAY_RESOLVERS: false,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
-  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: false,
   ENABLE_LOAD_QUERY_REQUEST_DEDUPING: true,
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: false,
   ENABLE_NOTIFY_SUBSCRIPTION: false,
+  BATCH_ASYNC_MODULE_UPDATES_FN: null,
+  ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT: false,
+  ENABLE_QUERY_RENDERER_OFFSCREEN_SUPPORT: false,
 };
 
 module.exports = RelayFeatureFlags;

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);
     }
   },
 };