@applicaster/quick-brick-core 13.0.0-rc.68 → 13.0.0-rc.69

package/App/ErrorBoundary/__tests__/errorBoundary.test.jsx

@@ -0,0 +1,232 @@
+import React from "react";
+import { View, Text, TouchableOpacity } from "react-native";
+import { render, fireEvent, act } from "@testing-library/react-native";
+import { useErrorStore } from "../store";
+import { ErrorBoundary } from "../index";
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/ErrorScreen",
+  () => ({
+    // eslint-disable-next-line react/prop-types
+    ErrorScreen: ({ dismissError, message, buttons }) => (
+      <View testID="error-screen">
+        <Text testID="error-message">{message || "Default error message"}</Text>
+        {/* eslint-disable-next-line react/prop-types */}
+        {buttons?.map((button, index) => (
+          <TouchableOpacity
+            key={index}
+            onPress={button.onPress}
+            testID={`button-${index}`}
+          >
+            <Text>{button.text}</Text>
+          </TouchableOpacity>
+        ))}
+
+        {dismissError ? (
+          <TouchableOpacity onPress={dismissError} testID="dismiss-button">
+            <Text>Dismiss Error</Text>
+          </TouchableOpacity>
+        ) : null}
+      </View>
+    ),
+  })
+);
+
+jest.mock("@applicaster/zapp-react-native-bridge/QuickBrick", () => ({
+  sendQuickBrickEvent: jest.fn(),
+  QUICK_BRICK_EVENTS: {
+    FORCE_APP_RELOAD: "force_app_reload",
+  },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => ({
+  coreLogger: {
+    addSubsystem: () => ({
+      error: jest.fn(),
+    }),
+  },
+}));
+
+// eslint-disable-next-line react/prop-types
+const TestComponent = ({ error, errorMessage = "error !!" }) => {
+  if (error) {
+    throw new Error(errorMessage);
+  }
+
+  return (
+    <View>
+      <Text>all is good</Text>
+    </View>
+  );
+};
+
+describe("<ErrorBoundary />", () => {
+  // Clear all error states between tests
+  beforeEach(() => {
+    useErrorStore.getState().dismissError();
+  });
+
+  describe("when there is no error", () => {
+    it("renders children correctly", () => {
+      const { getByText } = render(
+        <ErrorBoundary>
+          <TestComponent />
+        </ErrorBoundary>
+      );
+
+      expect(getByText("all is good")).toBeTruthy();
+    });
+  });
+
+  describe("when an error is caught", () => {
+    const _consoleLogs = {
+      error: console.error,
+      log: console.log,
+    };
+
+    beforeAll(() => {
+      console.error = jest.fn();
+      console.log = jest.fn();
+    });
+
+    afterAll(() => {
+      console.error = _consoleLogs.error;
+      console.log = _consoleLogs.log;
+    });
+
+    it("renders error state with default values (recoverable error)", () => {
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      expect(getByTestId("error-screen")).toBeTruthy();
+      expect(getByTestId("dismiss-button")).toBeTruthy(); // Should be recoverable by default
+    });
+
+    it("handles non-recoverable errors (no dismiss button)", () => {
+      const { getByTestId, queryByTestId } = render(
+        <ErrorBoundary recoverable={false}>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      expect(getByTestId("error-screen")).toBeTruthy();
+      expect(queryByTestId("dismiss-button")).toBeFalsy(); // Should not be recoverable
+    });
+
+    it("shows custom error message from caught error", () => {
+      const customErrorMessage = "Custom error message for testing";
+
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error errorMessage={customErrorMessage} />
+        </ErrorBoundary>
+      );
+
+      // The error info should be passed to the ErrorScreen
+      expect(getByTestId("error-message").props.children).toBeTruthy();
+    });
+
+    it("can dismiss the error and restore the UI", () => {
+      // First render with error
+      const { getByTestId, queryByText, rerender } = render(
+        <ErrorBoundary>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      // Verify error screen is shown
+      expect(getByTestId("error-screen")).toBeTruthy();
+
+      // Dismiss the error
+      fireEvent.press(getByTestId("dismiss-button"));
+
+      // Force rerender to see the change
+      rerender(
+        <ErrorBoundary>
+          <TestComponent />
+        </ErrorBoundary>
+      );
+
+      // Now the regular content should be visible
+      expect(queryByText("all is good")).toBeTruthy();
+    });
+  });
+
+  describe("error store functionality", () => {
+    it("properly sets error state", () => {
+      const error = new Error("Test error");
+      const errorInfo = "Test error info";
+
+      act(() => {
+        useErrorStore.getState().setError(error, errorInfo, true);
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.hasError).toBe(true);
+      expect(state.error).toBe(error);
+      expect(state.info).toBe(errorInfo);
+      expect(state.recoverable).toBe(true);
+    });
+
+    it("properly resets error state", () => {
+      // First set an error
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("Test error"), "Info", true);
+      });
+
+      // Then dismiss it
+      act(() => {
+        useErrorStore.getState().dismissError();
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.hasError).toBe(false);
+      expect(state.error).toBeUndefined();
+      expect(state.info).toBeUndefined();
+      expect(state.recoverable).toBe(true); // Default value when reset
+    });
+
+    it("remembers recoverable state", () => {
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("Test error"), "Info", false);
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.recoverable).toBe(false);
+    });
+  });
+
+  describe("integration with ErrorScreen", () => {
+    it("renders restart app button for non-recoverable errors", () => {
+      const { getAllByTestId } = render(
+        <ErrorBoundary recoverable={false}>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      // Should have the restart app button
+      const buttons = getAllByTestId(/button-/);
+      expect(buttons.length).toBeGreaterThan(0);
+    });
+
+    it("passes error info to the ErrorScreen component", () => {
+      const customErrorMessage = "Very specific error message";
+
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error errorMessage={customErrorMessage} />
+        </ErrorBoundary>
+      );
+
+      // The error info should be visible in the UI
+      expect(getByTestId("error-message")).toBeTruthy();
+    });
+  });
+});

package/App/ErrorBoundary/__tests__/store.test.js

@@ -0,0 +1,143 @@
+import { act, renderHook } from "@testing-library/react-hooks";
+import { useErrorStore } from "../store";
+
+describe("Error Store", () => {
+  beforeEach(() => {
+    act(() => {
+      useErrorStore.getState().dismissError();
+    });
+  });
+
+  describe("Initial state", () => {
+    it("should have correct default values", () => {
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+        error: undefined,
+        info: undefined,
+        recoverable: true,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+  });
+
+  describe("setError action", () => {
+    it("should set error state with provided values", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+      const isRecoverable = true;
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo, isRecoverable);
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        error: testError,
+        info: testInfo,
+        recoverable: isRecoverable,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+
+    it("should set non-recoverable error when specified", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+      const isRecoverable = false;
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo, isRecoverable);
+      });
+
+      expect(result.current).toMatchObject({
+        recoverable: false,
+      });
+    });
+
+    it("should default to recoverable error when not specified", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo);
+      });
+
+      expect(result.current).toMatchObject({
+        recoverable: true,
+      });
+    });
+  });
+
+  describe("dismissError action", () => {
+    it("should reset error state to defaults", () => {
+      const testError = new Error("Test error");
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, "info", false);
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        recoverable: false,
+      });
+
+      act(() => {
+        result.current.dismissError();
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+        error: undefined,
+        info: undefined,
+        recoverable: true,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+  });
+
+  describe("Direct store access via API", () => {
+    it("should allow direct access to store outside React components", () => {
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("API error"), "API info", false);
+      });
+
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        error: expect.objectContaining({ message: "API error" }),
+        info: "API info",
+        recoverable: false,
+      });
+    });
+
+    it("should allow clearing errors via API", () => {
+      act(() => {
+        useErrorStore.getState().setError(new Error("API error"), "API info");
+      });
+
+      act(() => {
+        useErrorStore.getState().dismissError();
+      });
+
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+      });
+    });
+  });
+});

package/App/ErrorBoundary/index.tsx

@@ -1,42 +1,66 @@
 import * as React from "react";
+import pick from "lodash/pick";
 
 import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
 import { ErrorScreen } from "@applicaster/zapp-react-native-ui-components/Components/ErrorScreen";
 
+import { useErrorStore } from "./store";
+import * as QuickBrickManager from "@applicaster/zapp-react-native-bridge/QuickBrick";
+
 const errorBoundaryLogger = coreLogger.addSubsystem("react_error-boundary");
 
 type Props = {
   children: React.ReactNode;
+  recoverable?: boolean;
 };
 
-type State = {
-  hasError: boolean;
-  error?: Error;
-  info?: string;
+type ErrorBoundaryContentProps = {
+  children: React.ReactNode;
 };
 
-export class ErrorBoundary extends React.Component<Props, State> {
-  state: State = {
-    hasError: false,
-    error: undefined,
-  };
+const restartApp = () => {
+  QuickBrickManager.sendQuickBrickEvent(
+    QuickBrickManager.QUICK_BRICK_EVENTS.FORCE_APP_RELOAD
+  );
+};
 
-  componentDidCatch(error, info) {
-    errorBoundaryLogger.error({ error, data: info, message: error.message });
-    this.setState({ hasError: true, error, info });
+const restartButton = {
+  text: "Restart the app",
+  onPress: restartApp,
+};
+
+const buttons = [restartButton];
+
+const ErrorBoundaryContent: React.FC<ErrorBoundaryContentProps> = ({
+  children,
+}) => {
+  const { hasError, dismissError, info } = pick(
+    useErrorStore((state) => state),
+    ["hasError", "dismissError", "info"]
+  );
+
+  if (hasError) {
+    return (
+      <ErrorScreen
+        dismissError={dismissError}
+        message={info}
+        buttons={buttons}
+      />
+    );
   }
 
-  dismissError = () => {
-    this.setState({ hasError: false });
-  };
+  return <>{children}</>;
+};
 
-  render() {
-    const { hasError } = this.state as State;
+export class ErrorBoundary extends React.Component<Props> {
+  componentDidCatch(error, info) {
+    errorBoundaryLogger.error({ error, data: info, message: error.message });
+    const { recoverable = true } = this.props;
 
-    if (hasError) {
-      return <ErrorScreen dismissError={this.dismissError} />;
-    }
+    useErrorStore.getState().setError(error, info, recoverable);
+  }
 
-    return this.props.children;
+  render() {
+    return <ErrorBoundaryContent>{this.props.children}</ErrorBoundaryContent>;
   }
 }

package/App/ErrorBoundary/store.ts

@@ -0,0 +1,26 @@
+import { create } from "zustand";
+
+type ErrorState = {
+  hasError: boolean;
+  error?: Error;
+  info?: string;
+  recoverable: boolean;
+  setError: (error: Error, info: string, recoverable?: boolean) => void;
+  dismissError: () => void;
+};
+
+export const useErrorStore = create<ErrorState>((set) => ({
+  hasError: false,
+  error: undefined,
+  info: undefined,
+  recoverable: true,
+  setError: (error: Error, info: string, recoverable = true) =>
+    set({ hasError: true, error, info, recoverable }),
+  dismissError: () =>
+    set({
+      hasError: false,
+      error: undefined,
+      info: undefined,
+      recoverable: true,
+    }),
+}));

package/App/remoteContextReloader/getRemoteContextData/getNativeRemoteContextData.ts

@@ -1,4 +1,5 @@
 import * as R from "ramda";
+import isEmpty from "lodash/isEmpty";
 import { Dimensions, NativeModules } from "react-native";
 import { loadAppContextData } from "@applicaster/zapp-react-native-redux";
 import { isTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
@@ -10,6 +11,7 @@ import { logger } from "@applicaster/zapp-react-native-utils/logger";
 import { ACTIVE_LAYOUT_ID_STORAGE_KEY } from "../consts";
 const { AppLoaderBridge } = NativeModules;
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { useErrorStore } from "../../ErrorBoundary/store";
 
 export async function getNativeRemoteContextData(
   dispatch,
@@ -58,6 +60,18 @@ export async function getNativeRemoteContextData(
 
   const layout = await getPromiseForType("layout");
 
+  const layoutLoadingErrorMessage = "Failed to load layout data";
+
+  if (isEmpty(layout)) {
+    useErrorStore
+      .getState()
+      .setError(
+        new Error(layoutLoadingErrorMessage),
+        layoutLoadingErrorMessage,
+        false
+      );
+  }
+
   const apiVersion = layout?.layout?.["api_version"]; // Taken from remote configuration
 
   dispatch(appDataActions.merge({ layoutVersion: apiVersion || "v1" }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "13.0.0-rc.68",
+  "version": "13.0.0-rc.69",
   "description": "Core package for Applicaster's Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -29,13 +29,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-rc.68",
-    "@applicaster/quick-brick-core-plugins": "13.0.0-rc.68",
-    "@applicaster/zapp-pipes-v2-client": "13.0.0-rc.68",
-    "@applicaster/zapp-react-native-bridge": "13.0.0-rc.68",
-    "@applicaster/zapp-react-native-redux": "13.0.0-rc.68",
-    "@applicaster/zapp-react-native-ui-components": "13.0.0-rc.68",
-    "@applicaster/zapp-react-native-utils": "13.0.0-rc.68",
+    "@applicaster/applicaster-types": "13.0.0-rc.69",
+    "@applicaster/quick-brick-core-plugins": "13.0.0-rc.69",
+    "@applicaster/zapp-pipes-v2-client": "13.0.0-rc.69",
+    "@applicaster/zapp-react-native-bridge": "13.0.0-rc.69",
+    "@applicaster/zapp-react-native-redux": "13.0.0-rc.69",
+    "@applicaster/zapp-react-native-ui-components": "13.0.0-rc.69",
+    "@applicaster/zapp-react-native-utils": "13.0.0-rc.69",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",

package/App/ErrorBoundary/__tests__/errorBoundary.test.js

@@ -1,55 +0,0 @@
-import React from "react";
-import { View, Text } from "react-native";
-import { render } from "@testing-library/react-native";
-
-import { ErrorBoundary } from "../index";
-
-const TestComponent = ({ error }: { error: any }) => {
-  if (error) {
-    throw new Error("error !!");
-  }
-
-  return (
-    <View>
-      <Text>all is good</Text>
-    </View>
-  );
-};
-
-describe("<ErrorBoundary />", () => {
-  describe("when there is no error", () => {
-    it("renders correctly", () => {
-      const { getByText } = render(
-        <ErrorBoundary>
-          <TestComponent />
-        </ErrorBoundary>
-      );
-
-      expect(getByText("all is good")).toBeTruthy();
-    });
-  });
-
-  describe("When an error is caught", () => {
-    const _consoleLog = console.log;
-
-    beforeAll(() => {
-      console.log = jest.fn();
-    });
-
-    afterAll(() => {
-      console.log = _consoleLog;
-    });
-
-    it("renders error state correctly", () => {
-      const { getByText } = render(
-        <ErrorBoundary>
-          <TestComponent error />
-        </ErrorBoundary>
-      );
-
-      // Note: You'll need to verify what your ErrorBoundary actually renders in error state
-      // This is just an example assertion:
-      expect(getByText(/error/i)).toBeTruthy();
-    });
-  });
-});