@applicaster/zapp-react-native-utils 13.0.0-rc.99 → 14.0.0-alpha.1216545755

package/storage/StorageSingleSelectProvider.ts

@@ -0,0 +1,108 @@
+import { bridgeLogger } from "../../zapp-react-native-bridge/logger";
+import { BehaviorSubject } from "rxjs";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { getNamespaceAndKey } from "../appUtils/contextKeysManager/utils";
+import { createLogger } from "../logger";
+
+export const { log_verbose, log_debug, log_warning, log_info, log_error } =
+  createLogger({
+    category: "StorageSingleValueProvider",
+    subsystem: "zapp-react-native-bridge",
+    parent: bridgeLogger,
+  });
+
+export interface SingleValueProvider {
+  getObservable(): BehaviorSubject<string | null>;
+
+  setValue(value: string): Promise<void>;
+  getValue(): string | null;
+  getValueAsync(): Promise<string | null>;
+  clearValue(): Promise<void>;
+}
+
+interface StorageListenerArgs {
+  value: string | null;
+}
+
+export class StorageSingleValueProvider implements SingleValueProvider {
+  // Static cache of providers by namespace
+  private static singleValueProviders: Record<
+    string,
+    StorageSingleValueProvider
+  > = {};
+
+  public static getProvider(keyNamespace: string): SingleValueProvider {
+    if (!this.singleValueProviders[keyNamespace]) {
+      this.singleValueProviders[keyNamespace] = new StorageSingleValueProvider(
+        keyNamespace
+      );
+    }
+
+    return this.singleValueProviders[keyNamespace];
+  }
+
+  private valueSubject: BehaviorSubject<string | null>;
+
+  private readonly key: string;
+  private readonly namespace: string;
+
+  private constructor(keyNamespace: string) {
+    const { namespace, key } = getNamespaceAndKey(keyNamespace);
+
+    if (!key) {
+      throw new Error("StorageSingleValueProvider: Key is required");
+    }
+
+    this.key = key;
+    this.namespace = namespace;
+    localStorage.addListener?.({ key, namespace }, this.reloadValue);
+
+    this.valueSubject = new BehaviorSubject<string | null>(null);
+
+    void this.getValueAsync();
+    log_debug("StorageSingleValueProvider: Initializing");
+  }
+
+  private reloadValue = async ({ value }: StorageListenerArgs) => {
+    log_debug(`reloadValue: request to reload value: ${value}`);
+
+    this.valueSubject.next(value);
+  };
+
+  public getObservable = (): BehaviorSubject<string | null> =>
+    this.valueSubject;
+
+  private async updateValueAndNotifyObservers(value: string | null) {
+    if (value === null) {
+      await localStorage.removeItem(this.key, this.namespace);
+    } else {
+      await localStorage.setItem(this.key, value, this.namespace);
+    }
+
+    this.valueSubject.next(value);
+  }
+
+  public setValue = async (value: string): Promise<void> => {
+    log_debug(`setValue: Setting new value: ${value}`);
+
+    await this.updateValueAndNotifyObservers(value);
+  };
+
+  public clearValue = async (): Promise<void> => {
+    await localStorage.removeItem(this.key, this.namespace);
+    log_debug("clearValue: Removing value");
+
+    this.valueSubject.next(null);
+  };
+
+  public getValueAsync = async (): Promise<string | null> => {
+    const value = await localStorage.getItem(this.key, this.namespace);
+    this.valueSubject.next(value);
+
+    return value;
+  };
+
+  public getValue = (): string | null => {
+    return this.valueSubject.getValue();
+  };
+}

package/typeGuards/index.ts

@@ -0,0 +1,3 @@
+export const isString = (value: unknown) => {
+  return typeof value === "string";
+};

package/utils/index.ts

@@ -2,4 +2,15 @@ export { chunk } from "./chunk";
 
 export { times } from "./times";
 
-export { cloneDeep as clone, flatten, drop, size } from "lodash";
+export {
+  cloneDeep as clone,
+  flatten,
+  drop,
+  size,
+  isNil,
+  isEmpty,
+  get,
+  has,
+  flatMap,
+  difference,
+} from "lodash";

package/zappFrameworkUtils/localStorageHelper.ts

@@ -7,6 +7,7 @@ import {
   StorageValuesToRemove,
   StorageValuesToAdd,
 } from "./types";
+import { Storage } from "@applicaster/zapp-react-native-bridge/ZappStorage/Storage";
 
 const defaultOwnedKey = "owned_keys";
 const DEFAULT_NAMESPACE = "applicaster.v2";
@@ -50,8 +51,9 @@ function mapOwnedKeysToAdd(
   return mappedData;
 }
 
-export async function batchSaveToLocalStorage(
-  storageValues: StorageValuesToAdd
+export async function batchSave(
+  storageValues: StorageValuesToAdd,
+  storage: Storage
 ) {
   if (isNilOrEmpty(storageValues)) {
     return false;
@@ -64,24 +66,37 @@ export async function batchSaveToLocalStorage(
       const value = namespaceData[key];
 
       if (!isNilOrEmpty(value)) {
-        await localStorage.setItem(key, value, namespace);
+        await storage.setItem(key, value, namespace);
       }
     }
   }
 }
 
-export async function batchRemoveFromLocalStorage(
-  storageValues: StorageValuesToRemove
+export async function batchSaveToLocalStorage(
+  storageValues: StorageValuesToAdd
+) {
+  return await batchSave(storageValues, localStorage);
+}
+
+export async function batchRemoveFromStorage(
+  storageValues: StorageValuesToRemove,
+  storage: Storage = localStorage
 ) {
   for (const namespace of Object.keys(storageValues)) {
     const namespaceData = storageValues[namespace];
 
     for (const key of namespaceData) {
-      await localStorage.removeItem(key, namespace);
+      await storage.removeItem(key, namespace);
     }
   }
 }
 
+export async function batchRemoveFromLocalStorage(
+  storageValues: StorageValuesToRemove
+) {
+  await batchRemoveFromStorage(storageValues, localStorage);
+}
+
 async function addOwnedKeys({
   newKeys,
   ownershipKey,
@@ -224,13 +239,20 @@ export async function batchRemoveOwnedNamespaceKeys({
   });
 }
 
-export async function batchRemoveAllFromNamespace(namespace) {
-  const allDataInNamespace = await localStorage.getAllItems(namespace);
+export async function batchRemoveAllFromNamespaceForStorage(
+  namespace: string,
+  storage: Storage
+) {
+  const allDataInNamespace = await storage.getAllItems(namespace);
   const keysToRemove = Object.keys(allDataInNamespace);
 
-  const dataToRemove = {
+  const dataToRemove: StorageValuesToRemove = {
     [namespace]: keysToRemove,
   };
 
-  await batchRemoveFromLocalStorage(dataToRemove);
+  await batchRemoveFromStorage(dataToRemove, storage);
+}
+
+export async function batchRemoveAllFromNamespace(namespace: string) {
+  await batchRemoveAllFromNamespaceForStorage(namespace, localStorage);
 }