@applicaster/zapp-react-native-utils 16.0.0-alpha.8716141508 → 16.0.0-alpha.9024462102

package/actionsExecutor/ActionExecutor.ts

@@ -12,7 +12,7 @@ const { log_error, log_debug, log_info } = createLogger({
   category: "General",
 });
 
-class ActionExecutor {
+export class ActionExecutor {
   private registeredActions: Record<string, ActionHandler> = {};
 
   // TODO: Remove context
@@ -56,7 +56,6 @@ class ActionExecutor {
     context?: ActionExecutionContext
   ): Promise<ActionResult> => {
     for (const action of actionTypes) {
-      // TODO: Handle action result error
       const result = await this.handleAction(action, context);
 
       if (result === ActionResult.Cancel) {
@@ -64,6 +63,16 @@ class ActionExecutor {
 
         return result;
       }
+
+      if (result === ActionResult.Error) {
+        // Everything after a failed step was written for a state that never
+        // happened — the event was refused, the screen never opened — so
+        // running it is how a chain ends up telling the user their mail was
+        // sent when it was not.
+        log_error(`handleActions: action: ${action.type} failed`, { action });
+
+        return result;
+      }
     }
 
     return ActionResult.Success;
@@ -101,7 +110,8 @@ class ActionExecutor {
 
   registerAction = <TOptions = Record<string, any>>(
     type: string,
-    handler: ActionHandler<TOptions>
+    handler: ActionHandler<TOptions>,
+    stateResolver?: (entry?: ZappEntry) => any
   ) => {
     if (this.registeredActions[type]) {
       log_error(`registerAction: action type: ${type} already registered`);
@@ -112,11 +122,48 @@ class ActionExecutor {
     this.registeredActions[type] = handler;
     log_debug(`registerAction: action type: ${type} registered`);
 
+    let unregisterState = () => {};
+
+    if (stateResolver) {
+      unregisterState = this.registerActionState(type, stateResolver);
+    }
+
     return () => {
       this.unregisterAction(type);
+      unregisterState();
       log_debug(`registerAction: action type: ${type} un-registered`);
     };
   };
+
+  private actionStates: Record<string, (entry?: ZappEntry) => any> = {};
+
+  registerActionState = (
+    type: string,
+    stateResolver: (entry?: ZappEntry) => any
+  ) => {
+    if (this.actionStates[type]) {
+      log_error(
+        `registerActionState: action type state: ${type} already registered`
+      );
+
+      return () => {};
+    }
+
+    this.actionStates[type] = stateResolver;
+    log_debug(`registerActionState: action type state: ${type} registered`);
+
+    return () => {
+      delete this.actionStates[type];
+
+      log_debug(
+        `registerActionState: action type state: ${type} un-registered`
+      );
+    };
+  };
+
+  getActionState = (type: string, entry?: ZappEntry) => {
+    return this.actionStates[type]?.(entry);
+  };
 }
 
 export const actionExecutor = new ActionExecutor();

package/actionsExecutor/ActionExecutorContext.tsx

@@ -9,7 +9,7 @@ import { ActionExecutionContext, ActionHandler } from "./types";
 import { batchRemoveAllFromNamespaceForStorage } from "../zappFrameworkUtils/localStorageHelper";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
 
-import { useNavigation, useRivers } from "../reactHooks";
+import { useNavigation, usePresentScreen, useRivers } from "../reactHooks";
 import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import { useSubscriberFor } from "../reactHooks/useSubscriberFor";
 import { APP_EVENTS } from "../appUtils/events";
@@ -18,10 +18,16 @@ import { createLogger } from "../logger";
 import {
   appRestartAction,
   confirmDialogAction,
+  showAlertAction,
+  createGoBackAction,
+  createGoHomeAction,
   createNavigateToScreenAction,
+  dismissBottomSheetAction,
   localStorageRemoveAction,
   localStorageSetAction,
   localStorageToggleFlagAction,
+  createPresentScreenAction,
+  openBottomSheetAction,
   refreshComponentAction,
   screenSetVariableAction,
   screenToggleFlagAction,
@@ -33,6 +39,8 @@ import {
   showToastAction,
 } from "./actions";
 
+import { ACTION_TYPES } from "./consts";
+
 export const { log_error, log_info, log_debug } = createLogger({
   subsystem: "ActionExecutorContext",
   category: "General",
@@ -41,9 +49,15 @@ export const { log_error, log_info, log_debug } = createLogger({
 export type ActionExecutorContextType = {
   registerAction: <TOptions = Record<string, any>>(
     type: string,
-    handler: ActionHandler<TOptions>
+    handler: ActionHandler<TOptions>,
+    stateResolver?: (entry?: ZappEntry) => any
   ) => void;
   unregisterAction: (type: string) => void;
+  registerActionState: (
+    type: string,
+    stateResolver: (entry?: ZappEntry) => any
+  ) => () => void;
+  getActionState: (type: string, entry?: ZappEntry) => any;
   handleAction: (
     action: ActionType,
     context?: ActionExecutionContext
@@ -63,34 +77,78 @@ type Props = {
 };
 
 const prepareDefaultActions = (actionExecutor) => {
-  actionExecutor.registerAction("localStorageSet", localStorageSetAction);
-  actionExecutor.registerAction("sessionStorageSet", sessionStorageSetAction);
-  actionExecutor.registerAction("localStorageRemove", localStorageRemoveAction);
+  actionExecutor.registerAction(
+    ACTION_TYPES.LOCAL_STORAGE_SET,
+    localStorageSetAction
+  );
+
+  actionExecutor.registerAction(
+    ACTION_TYPES.SESSION_STORAGE_SET,
+    sessionStorageSetAction
+  );
+
+  actionExecutor.registerAction(
+    ACTION_TYPES.LOCAL_STORAGE_REMOVE,
+    localStorageRemoveAction
+  );
 
   actionExecutor.registerAction(
-    "sessionStorageRemove",
+    ACTION_TYPES.SESSION_STORAGE_REMOVE,
     sessionStorageRemoveAction
   );
 
-  actionExecutor.registerAction("refreshComponent", refreshComponentAction);
-  actionExecutor.registerAction("switchLayout", switchLayoutAction);
-  actionExecutor.registerAction("appRestart", appRestartAction);
-  actionExecutor.registerAction("confirmDialog", confirmDialogAction);
-  actionExecutor.registerAction("sendCloudEvent", sendCloudEventAction);
+  actionExecutor.registerAction(
+    ACTION_TYPES.REFRESH_COMPONENT,
+    refreshComponentAction
+  );
+
+  actionExecutor.registerAction(ACTION_TYPES.SWITCH_LAYOUT, switchLayoutAction);
+
+  actionExecutor.registerAction(ACTION_TYPES.APP_RESTART, appRestartAction);
+
+  actionExecutor.registerAction(
+    ACTION_TYPES.CONFIRM_DIALOG,
+    confirmDialogAction
+  );
+
+  actionExecutor.registerAction(ACTION_TYPES.SHOW_ALERT, showAlertAction);
 
   actionExecutor.registerAction(
-    "sessionStorageToggleFlag",
+    ACTION_TYPES.SEND_CLOUD_EVENT,
+    sendCloudEventAction
+  );
+
+  actionExecutor.registerAction(
+    ACTION_TYPES.SESSION_STORAGE_TOGGLE_FLAG,
     sessionStorageToggleFlagAction
   );
 
   actionExecutor.registerAction(
-    "localStorageToggleFlag",
+    ACTION_TYPES.LOCAL_STORAGE_TOGGLE_FLAG,
     localStorageToggleFlagAction
   );
 
-  actionExecutor.registerAction("screenSetVariable", screenSetVariableAction);
-  actionExecutor.registerAction("screenToggleFlag", screenToggleFlagAction);
-  actionExecutor.registerAction("showToast", showToastAction);
+  actionExecutor.registerAction(
+    ACTION_TYPES.SCREEN_SET_VARIABLE,
+    screenSetVariableAction
+  );
+
+  actionExecutor.registerAction(
+    ACTION_TYPES.SCREEN_TOGGLE_FLAG,
+    screenToggleFlagAction
+  );
+
+  actionExecutor.registerAction(
+    ACTION_TYPES.OPEN_BOTTOM_SHEET,
+    openBottomSheetAction
+  );
+
+  actionExecutor.registerAction(
+    ACTION_TYPES.DISMISS_BOTTOM_SHEET,
+    dismissBottomSheetAction
+  );
+
+  actionExecutor.registerAction(ACTION_TYPES.SHOW_TOAST, showToastAction);
 };
 
 export const ActionExecutorContext =
@@ -103,11 +161,14 @@ export function withActionExecutor(Component) {
     const navigator = useNavigation();
     const rivers = useRivers();
     const contentTypes = useContentTypes();
+    const presentScreen = usePresentScreen();
 
     const handlers = useMemo(() => {
       return {
         unregisterAction: _actionExecutor.unregisterAction,
         registerAction: _actionExecutor.registerAction,
+        registerActionState: _actionExecutor.registerActionState,
+        getActionState: _actionExecutor.getActionState,
         handleAction: _actionExecutor.handleAction,
         handleActions: _actionExecutor.handleActions,
         handleEntryActions: _actionExecutor.handleEntryActions,
@@ -130,11 +191,32 @@ export function withActionExecutor(Component) {
 
     useEffect(() => {
       return _actionExecutor.registerAction(
-        "navigateToScreen",
+        ACTION_TYPES.NAVIGATE_TO_SCREEN,
         createNavigateToScreenAction(navigator, rivers, contentTypes)
       );
     }, [navigator, rivers, contentTypes]);
 
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        ACTION_TYPES.PRESENT_SCREEN,
+        createPresentScreenAction(presentScreen)
+      );
+    }, [presentScreen]);
+
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        ACTION_TYPES.GO_BACK,
+        createGoBackAction(navigator)
+      );
+    }, [navigator]);
+
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        ACTION_TYPES.GO_HOME,
+        createGoHomeAction(navigator)
+      );
+    }, [navigator]);
+
     return (
       <ActionExecutorContext.Provider value={handlers}>
         <Component {...props} />

package/actionsExecutor/__tests__/ActionExecutor.test.ts

@@ -0,0 +1,71 @@
+import { ActionExecutor, ActionResult } from "../ActionExecutor";
+
+jest.mock("../../logger", () => ({
+  createLogger: () => ({
+    log_error: jest.fn(),
+    log_debug: jest.fn(),
+    log_info: jest.fn(),
+  }),
+}));
+
+describe("handleActions", () => {
+  const executor = () => {
+    const ran: string[] = [];
+    const actionExecutor = new ActionExecutor();
+
+    const register = (type: string, result?: ActionResult) =>
+      actionExecutor.registerAction(type, async () => {
+        ran.push(type);
+
+        return result as ActionResult;
+      });
+
+    register("ok", ActionResult.Success);
+    register("fails", ActionResult.Error);
+    register("cancels", ActionResult.Cancel);
+    register("recover", ActionResult.Success);
+    register("after", ActionResult.Success);
+
+    return { actionExecutor, ran };
+  };
+
+  // Everything after a failed step was written for a state that never
+  // happened: the event was refused, the screen never opened.
+  it("stops when an action fails", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "fails" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["fails"]);
+    expect(result).toBe(ActionResult.Error);
+  });
+
+  it("still stops on a cancel", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "cancels" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["cancels"]);
+    expect(result).toBe(ActionResult.Cancel);
+  });
+
+  // An action nobody registered never ran, which is a misconfigured feed
+  // rather than a step that failed. It is stepped over, as it always was.
+  it("steps over an action with no handler", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "nobody-registered-this" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["after"]);
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/__tests__/feedDecorator.test.ts

@@ -0,0 +1,61 @@
+import { decorateFeed } from "../feedDecorator";
+
+const preferenceFeed = (selectMode: string) =>
+  ({
+    id: "agree-component",
+    title: "I agree to the terms",
+    type: { value: "feed" },
+    extensions: {
+      role: "preference_editor",
+      preference_editor_options: {
+        key: "agree",
+        scope: "screen",
+        select_mode: selectMode,
+      },
+    },
+    entry: [
+      {
+        id: "I agree to the terms-agree",
+        title: "I agree to the terms",
+        type: { value: "action" },
+        extensions: { tag: "true" },
+      },
+    ],
+  }) as unknown as ZappFeed;
+
+describe("decorateFeed", () => {
+  it("decorates single select feeds with screenSetVariable", () => {
+    const decorated = decorateFeed(preferenceFeed("single"));
+
+    expect(decorated.extensions.behavior).toEqual(
+      expect.objectContaining({
+        select_mode: "single",
+        current_selection: "@{screen/agree}",
+      })
+    );
+
+    expect(decorated.entry[0].extensions.tap_actions.actions[0].type).toBe(
+      "screenSetVariable"
+    );
+  });
+
+  it("decorates multi select feeds with screenToggleFlag", () => {
+    const decorated = decorateFeed(preferenceFeed("multi"));
+
+    expect(decorated.extensions.behavior.select_mode).toBe("multi");
+
+    expect(decorated.entry[0].extensions.tap_actions.actions[0].type).toBe(
+      "screenToggleFlag"
+    );
+  });
+
+  it("leaves a feed without the preference_editor role untouched", () => {
+    const feed = preferenceFeed("single");
+    feed.extensions.role = undefined;
+
+    const decorated = decorateFeed(feed);
+
+    expect(decorated.extensions.behavior).toBeUndefined();
+    expect(decorated.entry[0].extensions.tap_actions).toBeUndefined();
+  });
+});

package/actionsExecutor/actions/__tests__/dismissBottomSheet.test.ts

@@ -0,0 +1,25 @@
+import { dismissBottomSheetAction } from "../dismissBottomSheet";
+import { dismissModal } from "../../../modalState";
+import { ActionResult } from "../../ActionExecutor";
+
+jest.mock("../../../modalState", () => ({
+  dismissModal: jest.fn(),
+  modalOrchestrator: {
+    close: jest.fn(),
+  },
+}));
+
+describe("dismissBottomSheetAction", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("calls dismissModal and returns ActionResult.Success", async () => {
+    const result = await dismissBottomSheetAction({
+      type: "dismissBottomSheet",
+    });
+
+    expect(dismissModal).toHaveBeenCalledTimes(1);
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/__tests__/goBack.test.ts

@@ -0,0 +1,62 @@
+import { createGoBackAction } from "../goBack";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator(canGoBack = true) {
+  return {
+    goBack: jest.fn(),
+    canGoBack: jest.fn().mockReturnValue(canGoBack),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goBack", () => {
+  it("goes back with fallbackToHome enabled when no options are provided", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoBackAction(navigator)({ type: "goBack" });
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("forwards backToTop", async () => {
+    const navigator = createNavigator();
+
+    const action = {
+      type: "goBack",
+      options: { backToTop: true },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, true);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("goes back without falling back to home when the stack allows it", async () => {
+    const navigator = createNavigator(true);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(false, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("does nothing when there is nothing to go back to and fallbackToHome is off", async () => {
+    const navigator = createNavigator(false);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).not.toHaveBeenCalled();
+    expect(result).toBe(ActionResult.Error);
+  });
+});

package/actionsExecutor/actions/__tests__/goHome.test.ts

@@ -0,0 +1,19 @@
+import { createGoHomeAction } from "../goHome";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator() {
+  return {
+    goHome: jest.fn(),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goHome", () => {
+  it("navigates to the home screen", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoHomeAction(navigator)({ type: "goHome" });
+
+    expect(navigator.goHome).toHaveBeenCalledWith();
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/__tests__/loadItemsFromSource.test.ts

@@ -0,0 +1,88 @@
+import { loadItemsFromSource } from "../openBottomSheet";
+
+const mockCall = jest.fn();
+
+jest.mock("@applicaster/zapp-pipes-v2-client", () => ({
+  RequestBuilder: jest.fn().mockImplementation(() => ({
+    setEntryContext: jest.fn().mockReturnThis(),
+    setScreenContext: jest.fn().mockReturnThis(),
+    setUrl: jest.fn().mockReturnThis(),
+    buildAxiosRequest: jest.fn().mockResolvedValue(undefined),
+    call: (...args: any[]) => mockCall(...args),
+  })),
+  PipesClientResponseHelper: jest.fn().mockImplementation(() => ({
+    error: null,
+  })),
+}));
+
+describe("loadItemsFromSource", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns items plus role and behavior from feed.extensions", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [{ id: "a", title: "Playlist A", media_group: [] }],
+        extensions: {
+          role: "collection_selector",
+          behavior: {
+            select_mode: "multi",
+            current_selection: ["a"],
+            selector: "extensions.tag",
+          },
+        },
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/feed");
+
+    expect(result.role).toBe("collection_selector");
+
+    expect(result.behavior).toEqual({
+      selectMode: "multi",
+      currentSelection: ["a"],
+      selector: "extensions.tag",
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].isSelected).toBe(true);
+    expect(result.items[0].title).toBe("Playlist A");
+  });
+
+  it("returns undefined role/behavior when feed has no extensions", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [{ id: "1", title: "Plain", media_group: [] }],
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/plain");
+
+    expect(result.role).toBeUndefined();
+    expect(result.behavior).toBeUndefined();
+    expect(result.items).toHaveLength(1);
+  });
+
+  it("preserves events in dynamic_collection_options", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [],
+        extensions: {
+          dynamic_collection_options: {
+            operations: "add,remove",
+            events: {
+              add: [{ type: "showTextInput", options: {} }],
+            },
+          },
+        },
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/feed");
+
+    expect(result.dynamicCollection?.events).toEqual({
+      add: [{ type: "showTextInput", options: {} }],
+    });
+  });
+});