@applicaster/zapp-react-native-utils 13.0.0-rc.2 → 13.0.0-rc.21

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

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

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

@@ -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.js → index.ts}

@@ -10,14 +10,72 @@ 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({
@@ -25,7 +83,7 @@ export function HooksManager({
   targetScreen,
   plugins,
   startUpHooksData = {},
-}) {
+}: HookManagerArgs): HookManager {
   hooksManagerLogger.addContext({ targetScreen });
 
   function logHookEvent(func, message, data) {
@@ -35,7 +93,8 @@ export function HooksManager({
     });
   }
 
-  const hooksManager = subscriber();
+  const hooksManager: Partial<HookManager> = {};
+  hooksManager.subscriber = subscriber();
 
   /**
    * attaches the screen data to the hook object if the hook
@@ -100,15 +159,6 @@ 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
@@ -117,10 +167,10 @@ export function HooksManager({
    * @returns {Array<Hooks>} list of hooks to go through
    */
   function getHooks(hookType, river) {
-    const playerhooks = [];
+    const playerhooks: Hook[] = [];
 
-    if (riverIsPlayer(river)) {
-      playerhooks.push(...injectPlayerHooks(hookType));
+    if (riverIsPlayer(river, plugins)) {
+      playerhooks.push(...injectPlayerHooks(hookType, plugins));
     }
 
     let hooks = R.concat(playerhooks, R.pathOr([], ["hooks", hookType], river));
@@ -130,8 +180,10 @@ export function HooksManager({
     const { startUpHooks, setStartUpHooks } = startUpHooksData;
 
     if (startUpHooks && startUpHooks !== "in_process") {
-      hooks.unshift(...startUpHooks);
-      setStartUpHooks("in_process");
+      if (Array.isArray(startUpHooks)) {
+        hooks.unshift(...startUpHooks);
+        setStartUpHooks("in_process");
+      }
     }
 
     if (!R.length(hooks)) {
@@ -158,45 +210,6 @@ 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
@@ -209,6 +222,32 @@ 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
@@ -228,9 +267,11 @@ export function HooksManager({
       success,
       error,
       payload = initialPayload,
-      callback,
+      callback: callbackArg,
       cancelled,
     }) {
+      let callback = callbackArg;
+
       if (error) {
         logHookEvent(
           hooksManagerLogger.error,
@@ -272,7 +313,9 @@ export function HooksManager({
         const isHookInHomescreen = payload?.home;
 
         const isHookFlowBlocker =
-          hookPlugin?.module?.isFlowBlocker?.() ?? false;
+          typeof hookPlugin?.module?.isFlowBlocker === "function"
+            ? hookPlugin?.module?.isFlowBlocker()
+            : hookPlugin?.module?.isFlowBlocker;
 
         // 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
@@ -301,6 +344,18 @@ 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,
@@ -309,37 +364,11 @@ export function HooksManager({
 
         isLastHook(hookPlugin, restOfHooks)
           ? completeHook(hookPlugin, payload, callback)
-          : handleNextHook(restOfHooks, payload);
+          : executeOnNextHook(restOfHooks, payload, callback);
       }
     };
   }
 
-  /**
-   * 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
@@ -376,9 +405,6 @@ 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(
@@ -444,30 +470,13 @@ 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) {
+  hooksManager.handleHooks = function (payload: object) {
     const preloadHooks = getHooks(HOOKS_TYPE.PRELOAD, targetScreen);
 
     if (preloadHooks?.length) {
@@ -482,9 +491,9 @@ export function HooksManager({
         }
       );
 
-      handleNextHook(preloadHooks, payload);
+      executeOnNextHook(preloadHooks, payload, hookCallback);
     } else {
-      hooksManager.invokeHandler(HOOKS_EVENTS.COMPLETE, {
+      hooksManager.subscriber.invokeHandler(HOOKS_EVENTS.COMPLETE, {
         hookPlugin: { lastHook: true },
         payload,
       });
@@ -493,5 +502,5 @@ export function HooksManager({
     return hooksManager;
   };
 
-  return hooksManager;
+  return hooksManager as HookManager;
 }