Chain plugins to modify payload in sequence about analytics HOT 4 OPEN

export function namespacePluginHooks(
  plugins: object | object[],
  namespaces: string | string[],
  hooks?: string | string[]
) {
  if (!plugins) {
    throw TypeError(
      "namespacePluginHooks requires a single or a list of plugins."
    );
  }
  const pluginsArr = Array.isArray(plugins) ? plugins : [plugins];
  if (!namespaces) {
    throw TypeError(
      "namespacePluginHooks requires a single string or a list of strings as " +
      "namespaces."
    );
  }
  const namespaceArr = Array.isArray(namespaces) ? namespaces : [namespaces];
  const hooks_ = hooks ? hooks : ["track", "identify", "page"];
  const hooksArr = Array.isArray(hooks_) ? hooks_ : [hooks_];
  // For each plugin, make a namespaced copy of each hook for each namespace
  // So for namespaces ["ga", "hubspot"], and hooks ["track", "page"],
  // assigns these namespaced hooks to the current plugin:
  // ["track:ga", "track:hubspot", "page:ga", "page:hubspot"]
  return pluginsArr.map(plugin => {
    const namespacedPlugin = namespaceArr.reduce((nsPluginOuter, namespace) => {
      return hooksArr.reduce((nsPluginInner, hook) => {
        const namespacedKey = `${hook}:${namespace}`;
        nsPluginInner[namespacedKey] = plugin[hook];
        return nsPluginInner;
      }, nsPluginOuter);
    }, {});
    return {
      ...plugin,
      ...namespacedPlugin
    };
  });
}

/**
 * Compose multiple plugins into a single plugin object
 * whose hooks call underlying plugins' respective hooks sequentially,
 * compounding the modifications to the payload object.
 * @param {object} options Options object
 * @param {string} options.name Name of the newly-composed plugin.
 * @param {object[]} options.plugins List of plugin objects that should be
 *                                   combined together.
 */
export function composePlugins(options: {
  name: string;plugins: any[]
}) {
  const {
    name,
    plugins
  } = options;
  if (!plugins) {
    throw TypeError("composePlugin requires a list of plugins.");
  }
  // Chain plugin hooks from inside out, so that the outer (upstream) hook
  // first processes the payload, and then passes the augmented value to the
  // inner (downstream) hook
  const compositePlugin = [...plugins]
    .reverse()
    .reduce((aggPlugin, upstreamPlugin) => {
      Object.keys(upstreamPlugin)
        .filter(key => key !== "name" && key !== "config")
        .forEach(key => {
          if (!aggPlugin[key]) {
            aggPlugin[key] = ({
              payload
            }) => payload;
          }
          aggPlugin[key] = chainHooks(
            upstreamPlugin[key],
            aggPlugin[key],
            upstreamPlugin.config
          );
        });
      return aggPlugin;
    }, {});
  compositePlugin.name = name;
  return compositePlugin;
}

/**
 * Given two analytics plugin hook functions, returns a function which wraps
 * them such that the arguments are first passed to the first function, which
 * returns the updated payload, and the arguments along with the updated
 * payload are passed to the second function.
 * @param {Function} upstreamFn Hook that will be called first
 * @param {Function} downstreamFn Hook that will be called with payload
 *                                property updated from upstreamFn
 * @param {Object} config Config that should be passed to the upstream hook.
 *                        Defaults to the config of the plugin that was first
 *                        triggered by the event.
 */
function chainHooks(upstreamFn, downstreamFn, config = null) {
  function fnInner(eventCtx, ...args) {
    const currEventCtx = {
      ...eventCtx,
      config: config || eventCtx.config
    };
    const updatedEventCtx = {
      ...eventCtx,
      payload: upstreamFn.call(null, currEventCtx, ...args)
    };
    return downstreamFn.call(null, updatedEventCtx, ...args);
  }
  return fnInner;
}

Analytics({
  plugins: [
    // regular plugin
    doNotTrackPlugin(), 
   // scope the composed plugin so it's applied to payload when payload is sent to GA
    ...namespacePluginHooks(
      // create a composed plugin object with name "payload-pipeline"
      // whose methods sequentially call methods of children plugins
      // and pipe the payload through them
      composePlugins({
        name: "payload-pipeline",
        plugins: [
          enrichAnalyticsPlugin({ store, router }),
          dropNoValuePropertiesPlugin(),
          snakecasePropertiesPlugin()
        ]
      }),
      ["google-analytics"]
    ),
    // 3rd party plugins
    googleAnalyticsPlugin({ trackingId: gaTrackingID, autoTrack: true })
  ]
})