@applicaster/zapp-react-native-ui-components 16.0.0-rc.8 → 16.0.0-rc.80

package/Components/GeneralContentScreen/hookAdapter/__tests__/runInBackground.test.ts

@@ -0,0 +1,139 @@
+import { runInBackground } from "../runInBackground";
+import { shouldSkipHook } from "../validationHelper";
+import { requestToSkipHook } from "../networkService";
+
+jest.mock("../validationHelper", () => ({
+  shouldSkipHook: jest.fn(),
+}));
+
+jest.mock("../networkService", () => ({
+  requestToSkipHook: jest.fn(),
+}));
+
+jest.mock("../logger", () => ({
+  log_debug: jest.fn(),
+  log_error: jest.fn(),
+  log_info: jest.fn(),
+}));
+
+const mockShouldSkipHook = shouldSkipHook as jest.Mock;
+const mockRequestToSkipHook = requestToSkipHook as jest.Mock;
+
+const item = { id: "entry-1" };
+const endpoint = { source: "https://skip-endpoint", mapping: {} };
+
+describe("runInBackground", () => {
+  let callback: jest.Mock;
+  let presentUI: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    callback = jest.fn();
+    presentUI = jest.fn();
+    mockShouldSkipHook.mockResolvedValue(false);
+    mockRequestToSkipHook.mockResolvedValue(false);
+  });
+
+  it("presents the UI when no skip rules are configured", async () => {
+    await runInBackground(item, callback, {}, presentUI);
+
+    expect(presentUI).toHaveBeenCalled();
+    expect(callback).not.toHaveBeenCalled();
+    expect(mockShouldSkipHook).not.toHaveBeenCalled();
+    expect(mockRequestToSkipHook).not.toHaveBeenCalled();
+  });
+
+  it("finishes the hook when a storage key is found, without calling the endpoint", async () => {
+    mockShouldSkipHook.mockResolvedValue(true);
+
+    const configuration = {
+      rules: {
+        skip_hook_storage_key: "ns.key",
+        skip_hook_endpoint: endpoint,
+      },
+    };
+
+    await runInBackground(item, callback, configuration, presentUI);
+
+    expect(mockShouldSkipHook).toHaveBeenCalledWith("ns.key");
+
+    expect(callback).toHaveBeenCalledWith({
+      success: true,
+      error: null,
+      payload: item,
+    });
+
+    expect(mockRequestToSkipHook).not.toHaveBeenCalled();
+    expect(presentUI).not.toHaveBeenCalled();
+  });
+
+  it("falls through to the endpoint check when storage keys are not found", async () => {
+    const configuration = {
+      rules: {
+        skip_hook_storage_key: "ns.key",
+        skip_hook_endpoint: endpoint,
+      },
+    };
+
+    await runInBackground(item, callback, configuration, presentUI);
+
+    expect(mockRequestToSkipHook).toHaveBeenCalledWith(endpoint, item);
+    expect(presentUI).toHaveBeenCalled();
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it("finishes the hook when the endpoint allows skipping", async () => {
+    mockRequestToSkipHook.mockResolvedValue(true);
+
+    const configuration = {
+      rules: { skip_hook_endpoint: endpoint },
+    };
+
+    await runInBackground(item, callback, configuration, presentUI);
+
+    expect(callback).toHaveBeenCalledWith({
+      success: true,
+      error: null,
+      payload: item,
+    });
+
+    expect(presentUI).not.toHaveBeenCalled();
+  });
+
+  it("ignores an endpoint configuration without a source", async () => {
+    const configuration = {
+      rules: { skip_hook_endpoint: { mapping: {} } },
+    };
+
+    await runInBackground(item, callback, configuration, presentUI);
+
+    expect(mockRequestToSkipHook).not.toHaveBeenCalled();
+    expect(presentUI).toHaveBeenCalled();
+  });
+
+  it("presents the UI when the endpoint check throws", async () => {
+    mockRequestToSkipHook.mockRejectedValue(new Error("network down"));
+
+    const configuration = {
+      rules: { skip_hook_endpoint: endpoint },
+    };
+
+    await runInBackground(item, callback, configuration, presentUI);
+
+    expect(presentUI).toHaveBeenCalled();
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it("presents the UI when the storage check throws", async () => {
+    mockShouldSkipHook.mockRejectedValue(new Error("storage error"));
+
+    const configuration = {
+      rules: { skip_hook_storage_key: "ns.key" },
+    };
+
+    await runInBackground(item, callback, configuration, presentUI);
+
+    expect(presentUI).toHaveBeenCalled();
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/Components/GeneralContentScreen/hookAdapter/__tests__/skipExpression.test.ts

@@ -0,0 +1,294 @@
+import {
+  looksLikeSkipExpression,
+  parseSkipExpression,
+  evaluateSkipExpression,
+} from "../skipExpression";
+
+jest.mock("../logger", () => ({
+  log_debug: jest.fn(),
+  log_error: jest.fn(),
+  log_info: jest.fn(),
+}));
+
+const TOKEN = "quick-brick-login-flow.access_token";
+const PROFILE = "user_account.profile";
+
+/**
+ * Stands in for `getKeyToSkipHook`: resolves a "namespace.key" store, so the
+ * expression evaluator is exercised against real lookups rather than mocks.
+ */
+const storage = (store: Record<string, unknown>) =>
+  jest.fn((key: string, namespace?: string) =>
+    Promise.resolve(store[`${namespace}.${key}`])
+  );
+
+const evaluate = (expression: unknown, store: Record<string, unknown> = {}) =>
+  evaluateSkipExpression(parseSkipExpression(expression), storage(store));
+
+describe("looksLikeSkipExpression", () => {
+  it("recognises a JSON object, whatever its content", () => {
+    expect(looksLikeSkipExpression('{"exists":"ns.key"}')).toBe(true);
+    expect(looksLikeSkipExpression('  {"exists":"ns.key"}  ')).toBe(true);
+    expect(looksLikeSkipExpression({ exists: "ns.key" })).toBe(true);
+  });
+
+  it("recognises a malformed expression, so it is never read as a key list", () => {
+    expect(looksLikeSkipExpression('{"any":')).toBe(true);
+  });
+
+  it("rejects a legacy comma-separated key list", () => {
+    expect(looksLikeSkipExpression("ns1.key1, ns2.key2")).toBe(false);
+  });
+
+  it("rejects empty and missing input", () => {
+    expect(looksLikeSkipExpression("")).toBe(false);
+    expect(looksLikeSkipExpression("   ")).toBe(false);
+    expect(looksLikeSkipExpression(undefined)).toBe(false);
+  });
+});
+
+describe("parseSkipExpression", () => {
+  it("parses a JSON string into an expression object", () => {
+    expect(parseSkipExpression('{"exists":"ns.key"}')).toEqual({
+      exists: "ns.key",
+    });
+  });
+
+  it("ignores leading and trailing whitespace around the JSON", () => {
+    expect(parseSkipExpression('  {"exists":"ns.key"}  ')).toEqual({
+      exists: "ns.key",
+    });
+  });
+
+  it("accepts an expression that is already an object", () => {
+    expect(parseSkipExpression({ exists: "ns.key" })).toEqual({
+      exists: "ns.key",
+    });
+  });
+
+  it("returns null for a legacy comma-separated key list", () => {
+    expect(parseSkipExpression("ns1.key1, ns2.key2")).toBeNull();
+  });
+
+  it("returns null for a malformed JSON object", () => {
+    expect(parseSkipExpression('{"exists":')).toBeNull();
+  });
+
+  it("returns null for empty and missing input", () => {
+    expect(parseSkipExpression("")).toBeNull();
+    expect(parseSkipExpression(undefined)).toBeNull();
+    expect(parseSkipExpression(null)).toBeNull();
+  });
+
+  it("returns null for a JSON array, which is not a valid expression", () => {
+    expect(parseSkipExpression('["ns.key"]')).toBeNull();
+  });
+});
+
+describe("evaluateSkipExpression", () => {
+  it("returns false when there is no expression", async () => {
+    await expect(evaluateSkipExpression(null, storage({}))).resolves.toBe(
+      false
+    );
+  });
+
+  describe("exists", () => {
+    it("is true when the key holds a value", async () => {
+      await expect(
+        evaluate({ exists: "ns.key" }, { "ns.key": "value" })
+      ).resolves.toBe(true);
+    });
+
+    it("is false when the key is absent", async () => {
+      await expect(evaluate({ exists: "ns.key" })).resolves.toBe(false);
+    });
+
+    it("is false when the key holds an empty string", async () => {
+      await expect(
+        evaluate({ exists: "ns.key" }, { "ns.key": "" })
+      ).resolves.toBe(false);
+    });
+
+    it("splits the namespace on the last dot, like the legacy format", async () => {
+      const readKey = storage({ "com.applicaster.feature.someKey": "value" });
+
+      await evaluateSkipExpression(
+        { exists: "com.applicaster.feature.someKey" },
+        readKey
+      );
+
+      expect(readKey).toHaveBeenCalledWith(
+        "someKey",
+        "com.applicaster.feature"
+      );
+    });
+
+    it("treats a bare string operand as a shorthand for exists", async () => {
+      await expect(
+        evaluateSkipExpression("ns.key", storage({ "ns.key": "value" }))
+      ).resolves.toBe(true);
+    });
+  });
+
+  describe("missing", () => {
+    it("is true when the key is absent", async () => {
+      await expect(evaluate({ missing: "ns.key" })).resolves.toBe(true);
+    });
+
+    it("is false when the key holds a value", async () => {
+      await expect(
+        evaluate({ missing: "ns.key" }, { "ns.key": "value" })
+      ).resolves.toBe(false);
+    });
+  });
+
+  describe("equals", () => {
+    it("is true when the stored value matches", async () => {
+      await expect(
+        evaluate(
+          { equals: { key: "ns.key", value: "kids" } },
+          { "ns.key": "kids" }
+        )
+      ).resolves.toBe(true);
+    });
+
+    it("is false when the stored value differs", async () => {
+      await expect(
+        evaluate(
+          { equals: { key: "ns.key", value: "kids" } },
+          { "ns.key": "adults" }
+        )
+      ).resolves.toBe(false);
+    });
+
+    it("compares a non-string stored value by its string form", async () => {
+      await expect(
+        evaluate({ equals: { key: "ns.key", value: "42" } }, { "ns.key": 42 })
+      ).resolves.toBe(true);
+    });
+  });
+
+  describe("all", () => {
+    it("is true only when every operand is true", async () => {
+      await expect(
+        evaluate({ all: ["ns.a", "ns.b"] }, { "ns.a": "1", "ns.b": "2" })
+      ).resolves.toBe(true);
+    });
+
+    it("is false when one operand is false", async () => {
+      await expect(
+        evaluate({ all: ["ns.a", "ns.b"] }, { "ns.a": "1" })
+      ).resolves.toBe(false);
+    });
+
+    it("stops reading storage after the first false operand", async () => {
+      const readKey = storage({ "ns.b": "2" });
+
+      await evaluateSkipExpression({ all: ["ns.a", "ns.b"] }, readKey);
+
+      expect(readKey).toHaveBeenCalledTimes(1);
+    });
+
+    it("is false for an empty operand list", async () => {
+      await expect(evaluate({ all: [] })).resolves.toBe(false);
+    });
+  });
+
+  describe("any", () => {
+    it("is true when one operand is true", async () => {
+      await expect(
+        evaluate({ any: ["ns.a", "ns.b"] }, { "ns.b": "2" })
+      ).resolves.toBe(true);
+    });
+
+    it("is false when every operand is false", async () => {
+      await expect(evaluate({ any: ["ns.a", "ns.b"] })).resolves.toBe(false);
+    });
+
+    it("stops reading storage after the first true operand", async () => {
+      const readKey = storage({ "ns.a": "1", "ns.b": "2" });
+
+      await evaluateSkipExpression({ any: ["ns.a", "ns.b"] }, readKey);
+
+      expect(readKey).toHaveBeenCalledTimes(1);
+    });
+
+    it("is false for an empty operand list", async () => {
+      await expect(evaluate({ any: [] })).resolves.toBe(false);
+    });
+  });
+
+  describe("not", () => {
+    it("inverts a true operand", async () => {
+      await expect(
+        evaluate({ not: "ns.key" }, { "ns.key": "value" })
+      ).resolves.toBe(false);
+    });
+
+    it("inverts a false operand", async () => {
+      await expect(evaluate({ not: "ns.key" })).resolves.toBe(true);
+    });
+  });
+
+  describe("malformed expressions fail open", () => {
+    it("is false for an unknown operator", async () => {
+      await expect(evaluate({ matches: "ns.key" })).resolves.toBe(false);
+    });
+
+    it("is false for an operator carrying the wrong operand type", async () => {
+      await expect(evaluate({ exists: 42 })).resolves.toBe(false);
+      await expect(evaluate({ all: "ns.key" })).resolves.toBe(false);
+    });
+
+    it("is false for an operand list holding a malformed node", async () => {
+      await expect(
+        evaluate({ all: ["ns.a", { matches: "ns.b" }] }, { "ns.a": "1" })
+      ).resolves.toBe(false);
+    });
+
+    it("is false when a storage read throws", async () => {
+      const readKey = jest.fn(() => Promise.reject(new Error("storage error")));
+
+      await expect(
+        evaluateSkipExpression({ exists: "ns.key" }, readKey)
+      ).resolves.toBe(false);
+    });
+
+    it("keeps evaluating the other operands when one storage read throws", async () => {
+      const readKey = jest.fn((key: string) =>
+        key === "a"
+          ? Promise.reject(new Error("storage error"))
+          : Promise.resolve("value")
+      );
+
+      await expect(
+        evaluateSkipExpression({ any: ["ns.a", "ns.b"] }, readKey)
+      ).resolves.toBe(true);
+    });
+  });
+
+  describe("profile selector scenario", () => {
+    const skipProfileSelector = {
+      any: [{ missing: TOKEN }, { exists: PROFILE }],
+    };
+
+    it("shows the hook to a logged-in user who has not picked a profile yet", async () => {
+      await expect(
+        evaluate(skipProfileSelector, { [TOKEN]: "a-token" })
+      ).resolves.toBe(false);
+    });
+
+    it("skips the hook for a logged-out user", async () => {
+      await expect(evaluate(skipProfileSelector)).resolves.toBe(true);
+    });
+
+    it("skips the hook once a profile has been picked", async () => {
+      await expect(
+        evaluate(skipProfileSelector, {
+          [TOKEN]: "a-token",
+          [PROFILE]: "profile-id",
+        })
+      ).resolves.toBe(true);
+    });
+  });
+});

package/Components/GeneralContentScreen/hookAdapter/__tests__/validationHelper.test.ts

@@ -0,0 +1,188 @@
+import {
+  parseKeyEntries,
+  getKeyToSkipHook,
+  shouldSkipHook,
+} from "../validationHelper";
+
+const mockSessionGetItem = jest.fn();
+const mockLocalGetItem = jest.fn();
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage",
+  () => ({
+    sessionStorage: { getItem: (...args) => mockSessionGetItem(...args) },
+  })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: { getItem: (...args) => mockLocalGetItem(...args) },
+  })
+);
+
+jest.mock("../logger", () => ({
+  log_debug: jest.fn(),
+  log_error: jest.fn(),
+  log_info: jest.fn(),
+}));
+
+describe("parseKeyEntries", () => {
+  it("parses a namespaced key as namespace.key", () => {
+    expect(parseKeyEntries("myNamespace.myKey")).toEqual([
+      { namespace: "myNamespace", key: "myKey" },
+    ]);
+  });
+
+  it("treats everything before the last dot as the namespace", () => {
+    expect(parseKeyEntries("com.applicaster.feature.someKey")).toEqual([
+      { namespace: "com.applicaster.feature", key: "someKey" },
+    ]);
+  });
+
+  it("falls back to the default namespace when there is no dot", () => {
+    expect(parseKeyEntries("plainKey")).toEqual([
+      { namespace: "applicaster.v2", key: "plainKey" },
+    ]);
+  });
+
+  it("splits comma-separated entries, trimming whitespace and empty items", () => {
+    expect(parseKeyEntries(" ns1.key1 , , ns2.key2 ,")).toEqual([
+      { namespace: "ns1", key: "key1" },
+      { namespace: "ns2", key: "key2" },
+    ]);
+  });
+});
+
+describe("getKeyToSkipHook", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns the session storage value when present, without hitting local storage", async () => {
+    mockSessionGetItem.mockResolvedValue("session-value");
+
+    const value = await getKeyToSkipHook("myKey", "myNamespace");
+
+    expect(value).toBe("session-value");
+    expect(mockSessionGetItem).toHaveBeenCalledWith("myKey", "myNamespace");
+    expect(mockLocalGetItem).not.toHaveBeenCalled();
+  });
+
+  it("falls back to local storage when session storage is empty", async () => {
+    mockSessionGetItem.mockResolvedValue(null);
+    mockLocalGetItem.mockResolvedValue("local-value");
+
+    const value = await getKeyToSkipHook("myKey", "myNamespace");
+
+    expect(value).toBe("local-value");
+    expect(mockLocalGetItem).toHaveBeenCalledWith("myKey", "myNamespace");
+  });
+});
+
+describe("shouldSkipHook", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockSessionGetItem.mockResolvedValue(null);
+    mockLocalGetItem.mockResolvedValue(null);
+  });
+
+  it("returns false when no condition is provided", async () => {
+    await expect(shouldSkipHook(undefined)).resolves.toBe(false);
+    await expect(shouldSkipHook("")).resolves.toBe(false);
+    await expect(shouldSkipHook("   ")).resolves.toBe(false);
+  });
+
+  it("returns true when a key is found in storage, querying with parsed namespace and key", async () => {
+    mockSessionGetItem.mockResolvedValue("value");
+
+    await expect(shouldSkipHook("myNamespace.myKey")).resolves.toBe(true);
+    expect(mockSessionGetItem).toHaveBeenCalledWith("myKey", "myNamespace");
+  });
+
+  it("returns true when any of the comma-separated keys is found", async () => {
+    mockLocalGetItem.mockImplementation((key) =>
+      Promise.resolve(key === "key2" ? "value" : null)
+    );
+
+    await expect(shouldSkipHook("ns1.key1, ns2.key2")).resolves.toBe(true);
+  });
+
+  it("returns false when none of the keys are found", async () => {
+    await expect(shouldSkipHook("ns1.key1, ns2.key2")).resolves.toBe(false);
+    expect(mockSessionGetItem).toHaveBeenCalledTimes(2);
+    expect(mockLocalGetItem).toHaveBeenCalledTimes(2);
+  });
+
+  it("continues to the next key when a storage read throws", async () => {
+    mockSessionGetItem
+      .mockRejectedValueOnce(new Error("storage error"))
+      .mockResolvedValueOnce("value");
+
+    await expect(shouldSkipHook("ns1.key1, ns2.key2")).resolves.toBe(true);
+  });
+});
+
+describe("shouldSkipHook with a packed expression", () => {
+  const SKIP_UNLESS_LOGGED_IN_WITHOUT_PROFILE = JSON.stringify({
+    any: [
+      { missing: "quick-brick-login-flow.access_token" },
+      { exists: "user_account.profile" },
+    ],
+  });
+
+  const storedKeys = (store: Record<string, string>) => {
+    mockSessionGetItem.mockImplementation((key, namespace) =>
+      Promise.resolve(store[`${namespace}.${key}`] ?? null)
+    );
+
+    mockLocalGetItem.mockResolvedValue(null);
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    storedKeys({});
+  });
+
+  it("does not skip for a logged-in user who has not picked a profile yet", async () => {
+    storedKeys({ "quick-brick-login-flow.access_token": "a-token" });
+
+    await expect(
+      shouldSkipHook(SKIP_UNLESS_LOGGED_IN_WITHOUT_PROFILE)
+    ).resolves.toBe(false);
+  });
+
+  it("skips for a logged-out user", async () => {
+    await expect(
+      shouldSkipHook(SKIP_UNLESS_LOGGED_IN_WITHOUT_PROFILE)
+    ).resolves.toBe(true);
+  });
+
+  it("skips once a profile has been picked", async () => {
+    storedKeys({
+      "quick-brick-login-flow.access_token": "a-token",
+      "user_account.profile": "profile-id",
+    });
+
+    await expect(
+      shouldSkipHook(SKIP_UNLESS_LOGGED_IN_WITHOUT_PROFILE)
+    ).resolves.toBe(true);
+  });
+
+  it("falls back to local storage for a key the session does not hold", async () => {
+    mockLocalGetItem.mockResolvedValue("a-token");
+
+    await expect(
+      shouldSkipHook(JSON.stringify({ exists: "ns.key" }))
+    ).resolves.toBe(true);
+
+    expect(mockSessionGetItem).toHaveBeenCalledWith("key", "ns");
+    expect(mockLocalGetItem).toHaveBeenCalledWith("key", "ns");
+  });
+
+  it("returns false for a malformed expression instead of reading storage", async () => {
+    await expect(shouldSkipHook('{"any":')).resolves.toBe(false);
+    expect(mockSessionGetItem).not.toHaveBeenCalled();
+    expect(mockLocalGetItem).not.toHaveBeenCalled();
+  });
+});

package/Components/GeneralContentScreen/hookAdapter/logger.ts

@@ -0,0 +1,6 @@
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+export const { log_debug, log_error, log_info } = createLogger({
+  category: "runInBackground",
+  subsystem: "GeneralContentScreenHookAdapter",
+});

package/Components/GeneralContentScreen/hookAdapter/networkService.ts

@@ -0,0 +1,53 @@
+import {
+  PipesClientResponseHelper,
+  RequestBuilder,
+} from "@applicaster/zapp-pipes-v2-client";
+import { log_debug, log_error } from "./logger";
+
+export const requestToSkipHook = async (
+  dataSource: ZappDataSource,
+  payload: ZappEntry
+): Promise<boolean> => {
+  try {
+    const requestBuilder = new RequestBuilder()
+      .setEntryContext(payload)
+      // @ts-ignore: empty screen context is acceptable for this request
+      .setScreenContext({})
+      .setUrl(dataSource.source, dataSource.mapping);
+
+    const request = await requestBuilder.buildAxiosRequest();
+
+    log_debug(
+      `requestToSkipHook: Request built for source: ${
+        request?.url || dataSource.source
+      }`,
+      { ...request, source: dataSource.source }
+    );
+
+    const responseObject = await requestBuilder.call<boolean>();
+    const responseHelper = new PipesClientResponseHelper(responseObject);
+
+    const error = responseHelper.error;
+    const logData = responseHelper.getLogsData();
+
+    if (error) {
+      log_error(`requestToSkipHook: Error: ${error.message}`, {
+        response: logData,
+      });
+
+      throw error;
+    }
+
+    log_debug(
+      `requestToSkipHook: Request received successfully. Status: ${responseHelper.statusCode}`,
+      { response: logData }
+    );
+
+    // Non-empty body = skip the hook (same contract as hook-screen-wrapper)
+    return Boolean(responseHelper.responseData);
+  } catch (error) {
+    log_error(`requestToSkipHook: Error: ${error.message}`, { error });
+
+    throw error;
+  }
+};