@applicaster/zapp-react-native-utils 13.0.0-alpha.9433330286 → 13.0.0-rc.10

package/appUtils/HooksManager/__tests__/hooksManager.test.js

@@ -62,9 +62,9 @@ describe("HooksManager", () => {
     const successHandler = jest.fn();
 
     it("invokes the success handler directly", () => {
-      hooksManager.subscriber.on(HOOKS_EVENTS.COMPLETE, successHandler);
-
-      hooksManager.handleHooks(payload);
+      hooksManager
+        .on(HOOKS_EVENTS.COMPLETE, successHandler)
+        .handleHooks(payload);
 
       expect(successHandler).toHaveBeenCalledTimes(1);
 
@@ -103,12 +103,11 @@ describe("HooksManager", () => {
     const presentScreenHandler = jest.fn();
 
     it("executes the player hook", () => {
-      hooksManager.subscriber
+      hooksManager
         .on(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, presentScreenHandler)
         .on(HOOKS_EVENTS.SUCCESS, successHandler)
-        .on(HOOKS_EVENTS.COMPLETE, completeHandler);
-
-      hooksManager.handleHooks(payload);
+        .on(HOOKS_EVENTS.COMPLETE, completeHandler)
+        .handleHooks(payload);
 
       expect(headlessPlayerHook.module.run).toHaveBeenCalledWith(
         payload,
@@ -116,14 +115,20 @@ describe("HooksManager", () => {
         headlessPlayerHook.configuration
       );
 
-      expect(successHandler.mock.calls[0]).toMatchSnapshot();
+      expect(successHandler).toHaveBeenCalledWith(
+        { hookPlugin: expect.objectContaining(headlessPlayerHook), payload },
+        expect.any(Function)
+      );
 
-      expect(completeHandler.mock.calls[0]).toMatchSnapshot();
+      expect(completeHandler).toHaveBeenCalledWith(
+        { hookPlugin: expect.objectContaining(headlessPlayerHook), payload },
+        expect.any(Function)
+      );
     });
   });
 
   describe("when there are preload hooks", () => {
-    it("hook with screen: executes", () => {
+    describe("hook with screen", () => {
       const hookScreenId = "6e15fcbf-9414-4ea8-b7db-a287593ab6bd";
       const pluginScreenId = "1bb8ad39-a42e-4096-a134-56aadbd35c83";
 
@@ -152,29 +157,36 @@ describe("HooksManager", () => {
         }
       );
 
-      hooksManager.subscriber
-        .on(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, presentScreenHandler)
-        .on(HOOKS_EVENTS.SUCCESS, successHandler)
-        .on(HOOKS_EVENTS.COMPLETE, completeHandler);
+      it("executes the hook", () => {
+        hooksManager
+          .on(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, presentScreenHandler)
+          .on(HOOKS_EVENTS.SUCCESS, successHandler)
+          .on(HOOKS_EVENTS.COMPLETE, completeHandler)
+          .handleHooks(payload);
 
-      hooksManager.handleHooks(payload);
-
-      expect(presentScreenHandler).toHaveBeenCalledWith(
-        {
-          route: `/hooks/${pluginScreenId}`,
-          hookPlugin: expect.objectContaining(hookScreen),
-          payload: {
-            payload,
+        expect(presentScreenHandler).toHaveBeenCalledWith(
+          {
+            route: `/hooks/${pluginScreenId}`,
             hookPlugin: expect.objectContaining(hookScreen),
-            callback: expect.any(Function),
+            payload: {
+              payload,
+              hookPlugin: expect.objectContaining(hookScreen),
+              callback: expect.any(Function),
+            },
           },
-        },
-        expect.any(Function)
-      );
-
-      expect(successHandler.mock.calls[0]).toMatchSnapshot();
-
-      expect(completeHandler.mock.calls[0]).toMatchSnapshot();
+          expect.any(Function)
+        );
+
+        expect(successHandler).toHaveBeenCalledWith(
+          { payload, hookPlugin: expect.objectContaining(hookScreen) },
+          expect.any(Function)
+        );
+
+        expect(completeHandler).toHaveBeenCalledWith(
+          { payload, hookPlugin: expect.objectContaining(hookScreen) },
+          expect.any(Function)
+        );
+      });
     });
   });
 
@@ -214,12 +226,11 @@ describe("HooksManager", () => {
     });
 
     it("executes the hook", () => {
-      hooksManager.subscriber
+      hooksManager
         .on(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, presentScreenHandler)
         .on(HOOKS_EVENTS.SUCCESS, successHandler)
-        .on(HOOKS_EVENTS.COMPLETE, completeHandler);
-
-      hooksManager.handleHooks(payload);
+        .on(HOOKS_EVENTS.COMPLETE, completeHandler)
+        .handleHooks(payload);
 
       expect(presentScreenHandler).toHaveBeenCalledTimes(2);
 
@@ -330,13 +341,12 @@ describe("HooksManager", () => {
     );
 
     it("stops the flow", () => {
-      hooksManager.subscriber
+      hooksManager
         .on(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, presentScreenHandler)
         .on(HOOKS_EVENTS.CANCEL, cancelHandler)
         .on(HOOKS_EVENTS.SUCCESS, successHandler)
-        .on(HOOKS_EVENTS.COMPLETE, completeHandler);
-
-      hooksManager.handleHooks(payload);
+        .on(HOOKS_EVENTS.COMPLETE, completeHandler)
+        .handleHooks(payload);
 
       expect(cancelHandler).toHaveBeenCalledWith(
         { hookPlugin: expect.any(Object), payload },
@@ -360,28 +370,25 @@ describe("HooksManager", () => {
     const payload = { foo: "bar" };
 
     it("executes the hook", () => {
-      hooksManager.subscriber
+      hooksManager
         .on(HOOKS_EVENTS.SUCCESS, successHandler)
-        .on(HOOKS_EVENTS.COMPLETE, completeHandler);
-
-      hooksManager.handleHooks(payload);
-
-      expect(successHandler.mock.calls[0][0].payload).toMatchObject({
-        ...payload,
-        identifier: "hook_plugin",
-      });
+        .on(HOOKS_EVENTS.COMPLETE, completeHandler)
+        .handleHooks(payload);
 
-      expect(successHandler.mock.calls[0][0].hookPlugin).toMatchObject(
-        hookPlugin
+      expect(successHandler).toHaveBeenCalledWith(
+        {
+          payload: { ...payload, identifier: "hook_plugin" },
+          hookPlugin: expect.objectContaining(hookPlugin),
+        },
+        expect.any(Function)
       );
 
-      expect(completeHandler.mock.calls[0][0].payload).toMatchObject({
-        ...payload,
-        identifier: "hook_plugin",
-      });
-
-      expect(completeHandler.mock.calls[0][0].hookPlugin).toMatchObject(
-        hookPlugin
+      expect(completeHandler).toHaveBeenCalledWith(
+        {
+          payload: { ...payload, identifier: "hook_plugin" },
+          hookPlugin: expect.objectContaining(hookPlugin),
+        },
+        expect.any(Function)
       );
     });
   });
@@ -403,12 +410,11 @@ describe("HooksManager", () => {
     const hooksManager = HooksManager({ rivers, targetScreen, plugins });
 
     it("invokes the error handler but not the success handler", () => {
-      hooksManager.subscriber
+      hooksManager
         .on(HOOKS_EVENTS.SUCCESS, successHandler)
         .on(HOOKS_EVENTS.COMPLETE, completeHandler)
-        .on(HOOKS_EVENTS.ERROR, errorHandler);
-
-      hooksManager.handleHooks(payload);
+        .on(HOOKS_EVENTS.ERROR, errorHandler)
+        .handleHooks(payload);
 
       expect(successHandler).not.toHaveBeenCalled();
 
@@ -441,13 +447,12 @@ describe("HooksManager", () => {
     const hooksManager = HooksManager({ rivers, targetScreen, plugins });
 
     it("invokes the error handler, and stops the flow", () => {
-      hooksManager.subscriber
+      hooksManager
         .on(HOOKS_EVENTS.SUCCESS, successHandler)
         .on(HOOKS_EVENTS.COMPLETE, completeHandler)
         .on(HOOKS_EVENTS.ERROR, errorHandler)
-        .on(HOOKS_EVENTS.CANCEL, cancelHandler);
-
-      hooksManager.handleHooks(payload);
+        .on(HOOKS_EVENTS.CANCEL, cancelHandler)
+        .handleHooks(payload);
 
       expect(errorHandler).toHaveBeenCalledWith(
         {
@@ -502,50 +507,48 @@ describe("HooksManager", () => {
     const hooksManager = HooksManager({ rivers, targetScreen, plugins });
 
     it("executes the hook", () => {
-      hooksManager.subscriber
+      hooksManager
         .on(HOOKS_EVENTS.COMPLETE, completeHandler)
-        .on(HOOKS_EVENTS.SUCCESS, successHandler);
-
-      hooksManager.handleHooks(payload);
+        .on(HOOKS_EVENTS.SUCCESS, successHandler)
+        .handleHooks(payload);
 
       expect(successHandler).toHaveBeenCalledTimes(3);
 
-      expect(successHandler.mock.calls[0][0].payload).toMatchObject({
-        ...payload,
-        identifier: "hook_plugin",
-      });
-
-      expect(successHandler.mock.calls[0][0].hookPlugin).toMatchObject(
-        hookPlugin
+      expect(successHandler).toHaveBeenNthCalledWith(
+        1,
+        {
+          payload: { ...payload, identifier: "hook_plugin" },
+          hookPlugin: expect.objectContaining(hookPlugin),
+        },
+        expect.any(Function)
       );
 
-      expect(successHandler.mock.calls[1][0].payload).toMatchObject({
-        ...payload,
-        identifier: "hook_plugin_2",
-      });
-
-      expect(successHandler.mock.calls[1][0].hookPlugin).toMatchObject(
-        hookPlugin2
+      expect(successHandler).toHaveBeenNthCalledWith(
+        2,
+        {
+          payload: { ...payload, identifier: "hook_plugin_2" },
+          hookPlugin: expect.objectContaining(hookPlugin2),
+        },
+        expect.any(Function)
       );
 
-      expect(successHandler.mock.calls[2][0].payload).toMatchObject({
-        ...payload,
-        identifier: "hook_plugin_3",
-      });
-
-      expect(successHandler.mock.calls[2][0].hookPlugin).toMatchObject(
-        hookPlugin3
+      expect(successHandler).toHaveBeenNthCalledWith(
+        3,
+        {
+          payload: { ...payload, identifier: "hook_plugin_3" },
+          hookPlugin: expect.objectContaining(hookPlugin3),
+        },
+        expect.any(Function)
       );
 
       expect(completeHandler).toHaveBeenCalledTimes(1);
 
-      expect(completeHandler.mock.calls[0][0].payload).toMatchObject({
-        ...payload,
-        identifier: "hook_plugin_3",
-      });
-
-      expect(completeHandler.mock.calls[0][0].hookPlugin).toMatchObject(
-        hookPlugin3
+      expect(completeHandler).toHaveBeenCalledWith(
+        {
+          payload: { ...payload, identifier: "hook_plugin_3" },
+          hookPlugin: expect.objectContaining(hookPlugin3),
+        },
+        expect.any(Function)
       );
 
       expect(hookPlugin.module.run).toHaveBeenCalledWith(

package/appUtils/HooksManager/{constants.ts → constants.js}

@@ -12,7 +12,7 @@ export const HOOKS_EVENTS = {
   CANCEL: "cancel",
   SUCCESS: "success",
   COMPLETE: "complete",
-} as const;
+};
 
 export const HOOKS_TRANSITION_TYPE = {
   PUSH: "push",

package/appUtils/HooksManager/{index.ts → index.js}

@@ -10,72 +10,14 @@ import { Hook } from "./Hook";
 import { HOOKS_EVENTS, HOOKS_TYPE } from "./constants";
 
 import { hooksManagerLogger } from "./logger";
-import { HookManager, HookManagerArgs } from "./types";
-
-/**
- * orders the hooks according to their weight
- * @param {Array<object>} hooks to sort out
- * @returns {Array<object>} sorted hooks
- */
-function orderHooksByWeight(hooks: Hook[]) {
-  return R.sortBy(R.compose(Number, R.prop("weight")), hooks);
-}
-
-function executeOnNextHook(
-  hooks: Hook[],
-  payload: object,
-  callback: (hookPlugin: Hook, restOfHooks: Hook[], payload: object) => void
-) {
-  const [nextHook, ...restOfHooks] = orderHooksByWeight(hooks);
-
-  if (nextHook) {
-    nextHook.execute(payload, callback(nextHook, restOfHooks, payload));
-  }
-}
-
-/**
- * tells wether the current river is related to a player plugin, or the default player
- * @param {Object} river
- * @returns {boolean}
- */
-function riverIsPlayer(river, plugins) {
-  const { screenType, plugin_type } = river;
-
-  if (screenType || plugin_type) {
-    return screenType === "playable" || plugin_type === "player";
-  }
-
-  const { type } = river;
-
-  return R.compose(
-    R.propEq("type", "player"),
-    R.defaultTo({}),
-    R.find(R.propEq("identifier", type))
-  )(plugins);
-}
-
-/**
- * Injects the hooks for the player
- * @param _hookType type of hook
- * @param plugins plugins
- * @returns {Array<Object>}
- */
-function injectPlayerHooks(_hookType: string, plugins): Hook[] {
-  const playerhooks: Hook[] = R.compose(
-    R.sortBy(R.prop("weight")),
-    R.map((plugin) => ({
-      identifier: plugin.identifier,
-      weight: R.path(["module", "weight"], plugin) || 1,
-    })),
-    R.filter(R.pathEq(["module", "hasPlayerHook"], true))
-  )(plugins);
-
-  return playerhooks;
-}
 
 /**
  * creates a hooksManager object to handle the hooks process.
  * it is based on the `subscriber` object
+ * @param {object} options
+ * @param {object} rivers map of rivers in the app
+ * @param {object} targetScreen rivers which we are navigating to
+ * @param {Array<object>} plugins array of plugins in the app
  * @returns {object} hooksManager object - see Navigator for usage
  */
 export function HooksManager({
@@ -83,7 +25,7 @@ export function HooksManager({
   targetScreen,
   plugins,
   startUpHooksData = {},
-}: HookManagerArgs): HookManager {
+}) {
   hooksManagerLogger.addContext({ targetScreen });
 
   function logHookEvent(func, message, data) {
@@ -93,8 +35,7 @@ export function HooksManager({
     });
   }
 
-  const hooksManager: Partial<HookManager> = {};
-  hooksManager.subscriber = subscriber();
+  const hooksManager = subscriber();
 
   /**
    * attaches the screen data to the hook object if the hook
@@ -159,6 +100,15 @@ export function HooksManager({
     };
   }
 
+  /**
+   * orders the hooks according to their weight
+   * @param {Array<object>} hooks to sort out
+   * @returns {Array<object>} sorted hooks
+   */
+  function orderHooksByWeight(hooks) {
+    return R.sortBy(R.compose(Number, R.prop("weight")), hooks);
+  }
+
   /**
    * extracts the hooks form the target river. returns null if there are none
    * if there are hooks, gathers all required data and constructs a Hook object
@@ -167,10 +117,10 @@ export function HooksManager({
    * @returns {Array<Hooks>} list of hooks to go through
    */
   function getHooks(hookType, river) {
-    const playerhooks: Hook[] = [];
+    const playerhooks = [];
 
-    if (riverIsPlayer(river, plugins)) {
-      playerhooks.push(...injectPlayerHooks(hookType, plugins));
+    if (riverIsPlayer(river)) {
+      playerhooks.push(...injectPlayerHooks(hookType));
     }
 
     let hooks = R.concat(playerhooks, R.pathOr([], ["hooks", hookType], river));
@@ -180,10 +130,8 @@ export function HooksManager({
     const { startUpHooks, setStartUpHooks } = startUpHooksData;
 
     if (startUpHooks && startUpHooks !== "in_process") {
-      if (Array.isArray(startUpHooks)) {
-        hooks.unshift(...startUpHooks);
-        setStartUpHooks("in_process");
-      }
+      hooks.unshift(...startUpHooks);
+      setStartUpHooks("in_process");
     }
 
     if (!R.length(hooks)) {
@@ -210,6 +158,45 @@ export function HooksManager({
     )(hooks);
   }
 
+  /**
+   * tells wether the current river is related to a player plugin, or the default player
+   * @param {Object} river
+   * @returns {boolean}
+   */
+  function riverIsPlayer(river) {
+    const { screenType, plugin_type } = river;
+
+    if (screenType || plugin_type) {
+      return screenType === "playable" || plugin_type === "player";
+    }
+
+    const { type } = river;
+
+    return R.compose(
+      R.propEq("type", "player"),
+      R.defaultTo({}),
+      R.find(R.propEq("identifier", type))
+    )(plugins);
+  }
+
+  /**
+   * Injects the hooks for the player
+   * @param {String} hookType type of hook
+   * @returns {Array<Object>}
+   */
+  function injectPlayerHooks(_hookType) {
+    const playerhooks = R.compose(
+      R.sortBy(R.prop("weight")),
+      R.map((plugin) => ({
+        identifier: plugin.identifier,
+        weight: R.path(["module", "weight"], plugin) || 1,
+      })),
+      R.filter(R.pathEq(["module", "hasPlayerHook"], true))
+    )(plugins);
+
+    return playerhooks;
+  }
+
   /**
    * tells wether the given hook is the last one or not
    * @param {Hook} hookPlugin
@@ -222,32 +209,6 @@ export function HooksManager({
     return hookPlugin.lastHook;
   }
 
-  /**
-   * flags a hook as succeeded, and pass hook data along
-   * @param {Hook} hookPlugin
-   * @param {object} payload returned by the hook plugin
-   */
-  function completeHook(hookPlugin, payload, callback) {
-    logHookEvent(
-      hooksManagerLogger.info,
-      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
-      {
-        payload,
-        hook: hookPlugin,
-      }
-    );
-
-    // eslint-disable-next-line
-    // TODO: Temporary hack to pass getLoginProtocol to other plugins to refresh in case token expired, need be deleted later
-    delete payload.getLoginProtocol;
-
-    hookPlugin.setStateAndNotify(HOOKS_EVENTS.COMPLETE, {
-      hookPlugin,
-      payload,
-      callback,
-    });
-  }
-
   /**
    * creates the callback to invoke in order to proceed to the next hook
    * covers the scenarios of failure & flow blocking
@@ -267,11 +228,9 @@ export function HooksManager({
       success,
       error,
       payload = initialPayload,
-      callback: callbackArg,
+      callback,
       cancelled,
     }) {
-      let callback = callbackArg;
-
       if (error) {
         logHookEvent(
           hooksManagerLogger.error,
@@ -313,9 +272,7 @@ export function HooksManager({
         const isHookInHomescreen = payload?.home;
 
         const isHookFlowBlocker =
-          typeof hookPlugin?.module?.isFlowBlocker === "function"
-            ? hookPlugin?.module?.isFlowBlocker()
-            : hookPlugin?.module?.isFlowBlocker;
+          hookPlugin?.module?.isFlowBlocker?.() ?? false;
 
         // TODO: We technically need to also support the case where there is more than one hook in the stack,
         // if needed we could add differentiation explicit user cancellation (when we should go to background) and other types of cancellation
@@ -344,18 +301,6 @@ export function HooksManager({
           }
         );
 
-        if (!callback) {
-          logHookEvent(
-            hooksManagerLogger.warn,
-            `hookCallback: ${hookPlugin["identifier"]} is missing \`callback\`, using hookCallback(default one)`,
-            {
-              hookPlugin,
-            }
-          );
-
-          callback = hookCallback;
-        }
-
         hookPlugin.setStateAndNotify(HOOKS_EVENTS.SUCCESS, {
           hookPlugin,
           payload,
@@ -364,11 +309,37 @@ export function HooksManager({
 
         isLastHook(hookPlugin, restOfHooks)
           ? completeHook(hookPlugin, payload, callback)
-          : executeOnNextHook(restOfHooks, payload, callback);
+          : handleNextHook(restOfHooks, payload);
       }
     };
   }
 
+  /**
+   * flags a hook as succeeded, and pass hook data along
+   * @param {Hook} hookPlugin
+   * @param {object} payload returned by the hook plugin
+   */
+  function completeHook(hookPlugin, payload, callback) {
+    logHookEvent(
+      hooksManagerLogger.info,
+      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
+      {
+        payload,
+        hook: hookPlugin,
+      }
+    );
+
+    // eslint-disable-next-line
+    // TODO: Temporary hack to pass getLoginProtocol to other plugins to refresh in case token expired, need be deleted later
+    delete payload.getLoginProtocol;
+
+    hookPlugin.setStateAndNotify(HOOKS_EVENTS.COMPLETE, {
+      hookPlugin,
+      payload,
+      callback,
+    });
+  }
+
   /**
    * presents a screen hook by triggering an event invoking the handler with
    * the appropriate route & payload
@@ -405,6 +376,9 @@ export function HooksManager({
 
   /**
    * executes a headless hook
+   * @param {Hook} hookPlugin to present
+   * @param {object} payload to pass to the hook module
+   * @param {function} callback to invoke when the hook is successful
    */
   hooksManager.executeHook = function (hookPlugin, payload, callback) {
     logHookEvent(
@@ -470,13 +444,30 @@ export function HooksManager({
     }
   };
 
+  /**
+   * handles the next hook in the list of provided hooks, passing the payload along
+   * @param {Array<Hook>} hooks to process
+   * @param {object} payload to pass to the hook
+   */
+  function handleNextHook(hooks, payload) {
+    const [hookPlugin, ...restOfHooks] = orderHooksByWeight(hooks);
+
+    /**
+     * Commenting out part of the code which is trying to run the next hook
+     * in parallel - it's not in use, and it's creating unexpected side
+     * effects
+     * */
+
+    hookPlugin.execute(payload, hookCallback(hookPlugin, restOfHooks, payload));
+  }
+
   /**
    * function exposes on the hooks manager to trigger the handling of the hooks for
    * the given targetScreen
    * @param {object} payload to send to the hooks
    * @returns {object} returns the hooks manager so methods can be chained
    */
-  hooksManager.handleHooks = function (payload: object) {
+  hooksManager.handleHooks = function (payload) {
     const preloadHooks = getHooks(HOOKS_TYPE.PRELOAD, targetScreen);
 
     if (preloadHooks?.length) {
@@ -491,9 +482,9 @@ export function HooksManager({
         }
       );
 
-      executeOnNextHook(preloadHooks, payload, hookCallback);
+      handleNextHook(preloadHooks, payload);
     } else {
-      hooksManager.subscriber.invokeHandler(HOOKS_EVENTS.COMPLETE, {
+      hooksManager.invokeHandler(HOOKS_EVENTS.COMPLETE, {
         hookPlugin: { lastHook: true },
         payload,
       });
@@ -502,5 +493,5 @@ export function HooksManager({
     return hooksManager;
   };
 
-  return hooksManager as HookManager;
+  return hooksManager;
 }