@applicaster/zapp-react-native-utils/actionsExecutor/StorageActions.ts

Applicaster Zapp React Native utilities package

import { ActionResult } from "./ActionExecutor";
import { get } from "lodash";
import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-utils/storage/StorageMultiSelectProvider";
import { log_error, log_info } from "./ActionExecutorContext";
import { postEvent } from "../reactHooks/useSubscriberFor";
import { TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT } from "./consts";
import { StorageType } from "../appUtils/contextKeysManager/consts";

// send all data just in case (like for message string formatting)
// Type is not exported for now
type MaxTagsReachedEvent = {
  selectedItems: string[];
  maxItems: number;
  tag: string;
  keyNamespace: string;
};

export async function onMaxTagsReached(data: MaxTagsReachedEvent) {
  postEvent(TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT, [data]);
}

export async function storageToggleFlag(
  context: Record<string, any>,
  action: ActionType,
  storageType: StorageType
) {
  if (!context) {
    log_error("handleAction: localStorageToggleFlag action missing context");

    return ActionResult.Error;
  }

  const entry = context?.entry as ZappEntry;

  if (!entry) {
    log_error(
      "handleAction: localStorageToggleFlag action missing entry. Entry is required to get the tag."
    );

    return ActionResult.Error;
  }

  const tag = action.options?.selector
    ? get(entry, action.options.selector)
    : (entry.extensions?.tag ?? entry.id);

  const keyNamespace = action.options?.key;

  if (keyNamespace && tag) {
    const multiSelectProvider = StorageMultiSelectProvider.getProvider(
      keyNamespace,
      storageType
    );

    const selectedItems = await multiSelectProvider.getSelectedAsync();
    const isTagInSelectedItems = selectedItems.includes(tag);

    log_info(
      `handleAction: localStorageToggleFlag event will ${
        isTagInSelectedItems ? "remove" : "add"
      } tag: ${tag} for keyNamespace: ${keyNamespace}, current selectedItems: ${selectedItems}`
    );

    if (selectedItems.includes(tag)) {
      await multiSelectProvider.removeItem(tag);
    } else {
      const maxItems = action.options?.max_items;

      if (maxItems && selectedItems.length >= maxItems) {
        log_info(
          `handleAction: localStorageToggleFlag event reached max items limit: ${maxItems}, cannot add tag: ${tag}`
        );

        await onMaxTagsReached({
          selectedItems,
          maxItems,
          tag,
          keyNamespace,
        });

        return ActionResult.Cancel;
      }

      await multiSelectProvider.addItem(tag);
    }
  } else {
    log_error(
      "handleAction: localStorageToggleFlag event missing keyNamespace or tag",
      { keyNamespace, tag }
    );

    return ActionResult.Error;
  }

  return ActionResult.Success;
}

export async function sessionStorageToggleFlag(
  context: Record<string, any>,
  action: ActionType
) {
  return storageToggleFlag(context, action, StorageType.session);
}

export async function localStorageToggleFlag(
  context: Record<string, any>,
  action: ActionType
) {
  return storageToggleFlag(context, action, StorageType.local);
}