@applicaster/zapp-react-native-utils 15.0.0-rc.12 → 15.0.0-rc.121

package/errorUtils/__tests__/MissingPluginError.test.ts

@@ -0,0 +1,113 @@
+import { MissingPluginError } from "../MissingPluginError";
+import * as ERROR_CODES from "../errorCodes";
+
+describe("MissingPluginError", () => {
+  it("should create error with plugin identifier", () => {
+    const identifier = "com.example.myplugin";
+    const error = new MissingPluginError(identifier);
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error).toBeInstanceOf(MissingPluginError);
+    expect(error.message).toContain(identifier);
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should include error code in message", () => {
+    const identifier = "video-player";
+    const error = new MissingPluginError(identifier);
+
+    expect(error.message).toContain(ERROR_CODES.MISSING_PLUGIN);
+    expect(error.message).toContain("Error code:");
+  });
+
+  it("should include descriptive message", () => {
+    const identifier = "analytics-plugin";
+    const error = new MissingPluginError(identifier);
+
+    expect(error.message).toContain("Cannot find");
+    expect(error.message).toContain("plugin");
+
+    expect(error.message).toContain(
+      "Please make sure the plugin is properly added"
+    );
+  });
+
+  it("should have correct error code property", () => {
+    const error = new MissingPluginError("test-plugin");
+
+    expect(error.code).toBe("MISSING_PLUGIN");
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should be throwable and catchable", () => {
+    const identifier = "missing-plugin";
+
+    expect(() => {
+      throw new MissingPluginError(identifier);
+    }).toThrow(MissingPluginError);
+
+    try {
+      throw new MissingPluginError(identifier);
+    } catch (error) {
+      expect(error).toBeInstanceOf(MissingPluginError);
+
+      expect((error as MissingPluginError).code).toBe(
+        ERROR_CODES.MISSING_PLUGIN
+      );
+    }
+  });
+
+  it("should handle various identifier formats", () => {
+    const identifiers = [
+      "com.applicaster.plugin",
+      "my-plugin-123",
+      "plugin_name",
+      "Plugin Name With Spaces",
+      "123",
+    ];
+
+    identifiers.forEach((identifier) => {
+      const error = new MissingPluginError(identifier);
+      expect(error.message).toContain(identifier);
+      expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+    });
+  });
+
+  it("should maintain stack trace", () => {
+    const error = new MissingPluginError("stack-test-plugin");
+
+    expect(error.stack).toBeDefined();
+    expect(error.stack).toContain("stack-test-plugin");
+  });
+
+  it("should handle null identifier", () => {
+    const error = new MissingPluginError(null as any);
+
+    expect(error.message).toContain("null");
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should handle undefined identifier", () => {
+    const error = new MissingPluginError(undefined as any);
+
+    expect(error.message).toContain("undefined");
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should handle empty string identifier", () => {
+    const error = new MissingPluginError("");
+
+    expect(error.message).toBeDefined();
+    expect(error.code).toBe(ERROR_CODES.MISSING_PLUGIN);
+  });
+
+  it("should be distinguishable from other errors", () => {
+    const missingPluginError = new MissingPluginError("test");
+    const regularError = new Error("test");
+    const customError = { code: "MISSING_PLUGIN", message: "test" };
+
+    expect(missingPluginError).toBeInstanceOf(MissingPluginError);
+    expect(regularError).not.toBeInstanceOf(MissingPluginError);
+    expect(customError).not.toBeInstanceOf(MissingPluginError);
+  });
+});

package/errorUtils/__tests__/NetworkError.test.ts

@@ -0,0 +1,202 @@
+import { NetworkError } from "../NetworkError";
+import { HttpStatusCode } from "../HttpStatusCode";
+
+describe("NetworkError", () => {
+  describe("constructor", () => {
+    it("should create network error with message and status code", () => {
+      const message = "Request failed";
+      const statusCode = 404;
+      const error = new NetworkError(message, statusCode);
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(NetworkError);
+      expect(error.originalMessage).toBe(message);
+      expect(error.statusCode).toBe(statusCode);
+      expect(error.message).toContain("404");
+      expect(error.message).toContain(message);
+    });
+
+    it("should format readable log message", () => {
+      const message = "Not found";
+      const statusCode = 404;
+      const error = new NetworkError(message, statusCode);
+
+      expect(error.message).toContain("statusCode:");
+      expect(error.message).toContain("message:");
+      expect(error.message).toContain("readableStatus:");
+    });
+
+    it("should handle null message", () => {
+      const error = new NetworkError(null as any, 500);
+
+      expect(error.originalMessage).toBeNull();
+      expect(error.message).toContain("No error message available");
+    });
+
+    it("should handle undefined message", () => {
+      const error = new NetworkError(undefined as any, 500);
+
+      expect(error.originalMessage).toBeUndefined();
+      expect(error.message).toContain("No error message available");
+    });
+
+    it("should handle custom status codes", () => {
+      const message = "Custom error";
+      const statusCode = 999;
+      const error = new NetworkError(message, statusCode);
+
+      expect(error.statusCode).toBe(statusCode);
+      expect(error.message).toContain("999");
+    });
+  });
+
+  describe("isNetworkError static method", () => {
+    it("should return true for NetworkError instance", () => {
+      const error = new NetworkError("Test", 500);
+
+      expect(NetworkError.isNetworkError(error)).toBe(true);
+    });
+
+    it("should return false for regular Error", () => {
+      const error = new Error("Regular error");
+
+      expect(NetworkError.isNetworkError(error)).toBe(false);
+    });
+
+    it("should return false for other error types", () => {
+      class CustomError extends Error {}
+      const error = new CustomError("Custom");
+
+      expect(NetworkError.isNetworkError(error)).toBe(false);
+    });
+  });
+
+  describe("httpStatusCode getter", () => {
+    it("should return correct HttpStatusCode for 401", () => {
+      const error = new NetworkError("Unauthorized", 401);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.Unauthorized);
+    });
+
+    it("should return correct HttpStatusCode for 403", () => {
+      const error = new NetworkError("Forbidden", 403);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.Forbidden);
+    });
+
+    it("should return correct HttpStatusCode for 402", () => {
+      const error = new NetworkError("Payment Required", 402);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.PaymentRequired);
+    });
+
+    it("should return correct HttpStatusCode for 500", () => {
+      const error = new NetworkError("Server Error", 500);
+
+      expect(error.httpStatusCode).toBe(HttpStatusCode.InternalServerError);
+    });
+
+    it("should handle unknown status codes", () => {
+      const error = new NetworkError("Unknown", 999);
+
+      expect(error.httpStatusCode).toBe(999);
+    });
+  });
+
+  describe("isTokenExpired", () => {
+    it("should return true for 401 status code", () => {
+      const error = new NetworkError("Unauthorized", 401);
+
+      expect(error.isTokenExpired()).toBe(true);
+    });
+
+    it("should return false for non-401 status codes", () => {
+      expect(new NetworkError("Forbidden", 403).isTokenExpired()).toBe(false);
+      expect(new NetworkError("Not Found", 404).isTokenExpired()).toBe(false);
+
+      expect(new NetworkError("Server Error", 500).isTokenExpired()).toBe(
+        false
+      );
+    });
+  });
+
+  describe("isNoAccess", () => {
+    it("should return true for 403 status code", () => {
+      const error = new NetworkError("Forbidden", 403);
+
+      expect(error.isNoAccess()).toBe(true);
+    });
+
+    it("should return false for non-403 status codes", () => {
+      expect(new NetworkError("Unauthorized", 401).isNoAccess()).toBe(false);
+      expect(new NetworkError("Not Found", 404).isNoAccess()).toBe(false);
+      expect(new NetworkError("Server Error", 500).isNoAccess()).toBe(false);
+    });
+  });
+
+  describe("isPaymentRequired", () => {
+    it("should return true for 402 status code", () => {
+      const error = new NetworkError("Payment Required", 402);
+
+      expect(error.isPaymentRequired()).toBe(true);
+    });
+
+    it("should return false for non-402 status codes", () => {
+      expect(new NetworkError("Unauthorized", 401).isPaymentRequired()).toBe(
+        false
+      );
+
+      expect(new NetworkError("Forbidden", 403).isPaymentRequired()).toBe(
+        false
+      );
+
+      expect(new NetworkError("Not Found", 404).isPaymentRequired()).toBe(
+        false
+      );
+    });
+  });
+
+  describe("error handling scenarios", () => {
+    it("should be throwable and catchable", () => {
+      const message = "Test throw";
+      const statusCode = 500;
+
+      expect(() => {
+        throw new NetworkError(message, statusCode);
+      }).toThrow(NetworkError);
+
+      try {
+        throw new NetworkError(message, statusCode);
+      } catch (error) {
+        expect(error).toBeInstanceOf(NetworkError);
+        expect((error as NetworkError).originalMessage).toBe(message);
+        expect((error as NetworkError).statusCode).toBe(statusCode);
+      }
+    });
+
+    it("should maintain stack trace", () => {
+      const error = new NetworkError("Stack test", 500);
+
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain("Error data:");
+    });
+
+    it("should handle multiple error scenarios", () => {
+      const unauthorizedError = new NetworkError("Token expired", 401);
+      const forbiddenError = new NetworkError("Access denied", 403);
+      const paymentError = new NetworkError("Subscription required", 402);
+
+      expect(unauthorizedError.isTokenExpired()).toBe(true);
+      expect(unauthorizedError.isNoAccess()).toBe(false);
+      expect(unauthorizedError.isPaymentRequired()).toBe(false);
+
+      expect(forbiddenError.isTokenExpired()).toBe(false);
+      expect(forbiddenError.isNoAccess()).toBe(true);
+      expect(forbiddenError.isPaymentRequired()).toBe(false);
+
+      expect(paymentError.isTokenExpired()).toBe(false);
+      expect(paymentError.isNoAccess()).toBe(false);
+      expect(paymentError.isPaymentRequired()).toBe(true);
+    });
+  });
+});

package/errorUtils/__tests__/getParsedResponse.test.ts

@@ -0,0 +1,188 @@
+import { getParsedResponse } from "../index";
+import { RESPONSES } from "../errorCodes";
+
+describe("getParsedResponse", () => {
+  it("should parse error with response status code from response.data", () => {
+    const err = {
+      response: {
+        data: {
+          statusCode: 404,
+          message: "Resource not found",
+        },
+        config: {
+          url: "https://api.example.com/data",
+          params: { id: 123 },
+        },
+      },
+      name: "AxiosError",
+      context: { userId: "user123" },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: Resource not found");
+    expect(result.data.statusCode).toBe("404");
+    expect(result.data.url).toBe("https://api.example.com/data");
+    expect(result.data.params).toEqual({ id: 123 });
+    expect(result.data.context).toEqual({ userId: "user123" });
+    expect(result.data.name).toBe("AxiosError");
+    expect(result.jsOnly).toBe(false);
+    expect(result.exception).toBe(result.message);
+  });
+
+  it("should parse error with response status code from response.status", () => {
+    const err = {
+      response: {
+        status: 500,
+        config: {
+          url: "https://api.example.com/data",
+        },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES[500]}`);
+    expect(result.data.statusCode).toBe("500");
+  });
+
+  it("should handle error with request but no response", () => {
+    const err = {
+      request: {},
+      message: "Network timeout",
+      config: {
+        url: "https://api.example.com/data",
+        params: { test: "value" },
+      },
+      name: "NetworkError",
+      context: { app: "test" },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: Network timeout");
+    expect(result.data.url).toBe("https://api.example.com/data");
+    expect(result.data.params).toEqual({ test: "value" });
+    expect(result.data.name).toBe("NetworkError");
+    expect(result.data.context).toEqual({ app: "test" });
+    expect(result.jsOnly).toBe(false);
+  });
+
+  it("should handle error with request but no response and no message", () => {
+    const err = {
+      request: {},
+      config: {
+        url: "https://api.example.com/data",
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.noResponse}`);
+  });
+
+  it("should handle error with neither response nor request", () => {
+    const err = {
+      message: "Failed to set up request",
+      config: {
+        url: "https://api.example.com/data",
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: Failed to set up request");
+  });
+
+  it("should handle error with neither response nor request and no message", () => {
+    const err = {
+      config: {
+        url: "https://api.example.com/data",
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.unknown}`);
+  });
+
+  it("should handle null error", () => {
+    const err = null;
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.unknown}`);
+
+    expect(result.data).toEqual({
+      context: undefined,
+      name: undefined,
+      params: undefined,
+      url: undefined,
+    });
+  });
+
+  it("should handle undefined error", () => {
+    const err = undefined;
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.unknown}`);
+  });
+
+  it("should extract params from err.config when response is not present", () => {
+    const err = {
+      request: {},
+      message: "Request failed",
+      config: {
+        url: "https://api.example.com/data",
+        params: { key: "value" },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.data.params).toEqual({ key: "value" });
+    expect(result.data.url).toBe("https://api.example.com/data");
+  });
+
+  it("should prioritize response config over error config", () => {
+    const err = {
+      response: {
+        status: 404,
+        config: {
+          url: "https://api.example.com/response-url",
+          params: { from: "response" },
+        },
+      },
+      config: {
+        url: "https://api.example.com/error-url",
+        params: { from: "error" },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.data.url).toBe("https://api.example.com/response-url");
+    expect(result.data.params).toEqual({ from: "response" });
+  });
+
+  it("should handle response with custom status codes", () => {
+    const err = {
+      response: {
+        data: {
+          statusCode: 418,
+          message: "I'm a teapot",
+        },
+        status: 418,
+        config: {
+          url: "https://api.example.com/coffee",
+        },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: I'm a teapot");
+    expect(result.data.statusCode).toBe("418");
+  });
+});

package/errorUtils/__tests__/invariant.test.ts

@@ -0,0 +1,112 @@
+import { invariant } from "../index";
+
+// Mock __DEV__ global
+declare global {
+  var __DEV__: boolean;
+}
+
+describe("invariant", () => {
+  const originalDev = global.__DEV__;
+
+  afterEach(() => {
+    global.__DEV__ = originalDev;
+  });
+
+  describe("in development mode", () => {
+    beforeEach(() => {
+      global.__DEV__ = true;
+    });
+
+    it("should not throw when condition is true", () => {
+      expect(() => {
+        invariant(true, "This should not throw");
+      }).not.toThrow();
+    });
+
+    it("should throw when condition is false", () => {
+      expect(() => {
+        invariant(false, "This should throw");
+      }).toThrow("This should throw");
+    });
+
+    it("should throw with correct error message", () => {
+      const errorMessage = "Custom error message";
+
+      expect(() => {
+        invariant(false, errorMessage);
+      }).toThrow(errorMessage);
+    });
+
+    it("should not throw when condition is truthy value", () => {
+      expect(() => {
+        invariant(1 as any, "Should not throw");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant("string" as any, "Should not throw");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant({} as any, "Should not throw");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant([] as any, "Should not throw");
+      }).not.toThrow();
+    });
+
+    it("should throw when condition is falsy value", () => {
+      expect(() => {
+        invariant(0 as any, "Should throw for 0");
+      }).toThrow("Should throw for 0");
+
+      expect(() => {
+        invariant("" as any, "Should throw for empty string");
+      }).toThrow("Should throw for empty string");
+
+      expect(() => {
+        invariant(null as any, "Should throw for null");
+      }).toThrow("Should throw for null");
+
+      expect(() => {
+        invariant(undefined as any, "Should throw for undefined");
+      }).toThrow("Should throw for undefined");
+
+      expect(() => {
+        invariant(NaN as any, "Should throw for NaN");
+      }).toThrow("Should throw for NaN");
+    });
+  });
+
+  describe("in production mode", () => {
+    beforeEach(() => {
+      global.__DEV__ = false;
+    });
+
+    it("should not throw when condition is true", () => {
+      expect(() => {
+        invariant(true, "This should not throw");
+      }).not.toThrow();
+    });
+
+    it("should not throw when condition is false", () => {
+      expect(() => {
+        invariant(false, "This should not throw in production");
+      }).not.toThrow();
+    });
+
+    it("should not throw for any condition", () => {
+      expect(() => {
+        invariant(0 as any, "Should not throw in production");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant(null as any, "Should not throw in production");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant(undefined as any, "Should not throw in production");
+      }).not.toThrow();
+    });
+  });
+});

package/focusManager/aux/index.ts

@@ -49,7 +49,7 @@ export const findSelectedMenuId = (
 ) => {
   const sectionName = QUICK_BRICK_NAVBAR_SECTIONS[sectionKey];
 
-  return pathOr(
+  return pathOr<string | undefined>(
     undefined,
     ["children", index, "id"],
     focusableTree.find(sectionName)

package/headersUtils/__tests__/headersUtils.test.js

@@ -1,6 +1,15 @@
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { getAppDataHeaders } from "../index";
 
+const mockUILanguage = "en-US";
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/localizationsHelper",
+  () => ({
+    getUILanguage: jest.fn(() => mockUILanguage),
+  })
+);
+
 describe("getAppDataHeaders", () => {
   const mockAppData = {
     riversConfigurationId: "test-layout",
@@ -25,7 +34,7 @@ describe("getAppDataHeaders", () => {
     const expectedHeaders = {
       "x-applicaster-layout-id": mockAppData.riversConfigurationId,
       "x-applicaster-screen-id": screenId,
-      "x-applicaster-language-code": mockAppData.languageCode,
+      "x-applicaster-language-code": mockUILanguage,
       "x-applicaster-version-number": mockAppData.version_name,
       "x-applicaster-platform": mockAppData.platform,
       "x-applicaster-country-code": mockAppData.countryCode,
@@ -33,6 +42,7 @@ describe("getAppDataHeaders", () => {
         mockAppData.signedDeviceInfoToken,
       "x-applicaster-device-make": mockAppData.deviceMake,
       "x-applicaster-device-model": mockAppData.deviceModel,
+      "x-applicaster-uuid": undefined,
     };
 
     const headers = getAppDataHeaders(screenId);

package/headersUtils/index.ts

@@ -1,6 +1,7 @@
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { getPlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { utilsLogger } from "../logger";
+import { getUILanguage } from "../localizationUtils";
 
 const logger = utilsLogger.addSubsystem("headersUtils");
 
@@ -21,7 +22,7 @@ export const getAppDataHeaders = (screenId: string) => {
     "x-applicaster-layout-id":
       appData.riversConfigurationId || appData.rivers_configuration_id,
     "x-applicaster-screen-id": screenId,
-    "x-applicaster-language-code": appData.languageCode,
+    "x-applicaster-language-code": getUILanguage(),
     "x-applicaster-version-number": appData.version_name || appData.versionName,
     "x-applicaster-platform": (platform || appData.platform).toLowerCase(),
     "x-applicaster-country-code": appData.countryCode,