Inji-400: Cache api calls and return initial values if network not available (#883)

* feat(inji-400): Use Initial Config for all properties incase cache and network not available.

* feat(inji-400): Create cache apis to fetch and cache issuer api's

* feat(inji-400): Update Initial Config comments and remove qa-inji urls

* feat(inji-400): Rename catchAPIMethod to generateCacheAPIFunction

* feat(inji-400): Rename qa inji url from warningDomainName

* feat(inji-400): Update logs for api calls

---------

Signed-off-by: Swati Goel <meet2swati@gmail.com>
Co-authored-by: Swati Goel <meet2swati@gmail.com>

shared/api.ts

@@ -0,0 +1,168 @@
+import {request} from './request';
+import Storage, {API_CACHED_STORAGE_KEYS} from './storage';
+import {COMMON_PROPS_KEY} from './commonprops/commonProps';
+import {INITIAL_CONFIG} from './InitialConfig';
+
+export const API_URLS = {
+  issuersList: {
+    method: 'GET',
+    buildURL: (): `/${string}` => '/residentmobileapp/issuers',
+  },
+  issuerConfig: {
+    method: 'GET',
+    buildURL: (issuerId: string): `/${string}` =>
+      `/residentmobileapp/issuers/${issuerId}`,
+  },
+  allProperties: {
+    method: 'GET',
+    buildURL: (): `/${string}` => '/residentmobileapp/allProperties',
+  },
+};
+
+export const API = {
+  fetchIssuers: async () => {
+    const defaultIssuer = {
+      id: 'UIN, VID, AID',
+      displayName: 'UIN, VID, AID',
+    };
+
+    const response = await request(
+      API_URLS.issuersList.method,
+      API_URLS.issuersList.buildURL(),
+    );
+    return [defaultIssuer, ...(response.response.issuers || [])];
+  },
+
+  fetchIssuerConfig: async (issuerId: string) => {
+    const response = await request(
+      API_URLS.issuerConfig.method,
+      API_URLS.issuerConfig.buildURL(issuerId),
+    );
+    return response.response;
+  },
+
+  fetchAllProperties: async () => {
+    const response = await request(
+      API_URLS.allProperties.method,
+      API_URLS.allProperties.buildURL(),
+    );
+    return response.response;
+  },
+};
+
+export const CACHED_API = {
+  fetchIssuers: () =>
+    generateCacheAPIFunction({
+      cacheKey: API_CACHED_STORAGE_KEYS.fetchIssuers,
+      fetchCall: API.fetchIssuers,
+    }),
+
+  fetchIssuerConfig: (issuerId: string) =>
+    generateCacheAPIFunction({
+      cacheKey: API_CACHED_STORAGE_KEYS.fetchIssuerConfig(issuerId),
+      fetchCall: API.fetchIssuerConfig.bind(null, issuerId),
+    }),
+
+  getAllProperties: () =>
+    generateCacheAPIFunction({
+      isCachePreferred: true,
+      cacheKey: COMMON_PROPS_KEY,
+      fetchCall: API.fetchAllProperties,
+      onErrorHardCodedValue: INITIAL_CONFIG.allProperties,
+    }),
+};
+
+interface GenerateCacheAPIFunctionProps {
+  isCachePreferred?: boolean;
+  cacheKey: string;
+  fetchCall: (...props: any) => Promise<any>;
+  onErrorHardCodedValue?: any;
+}
+
+async function generateCacheAPIFunction({
+  isCachePreferred = false,
+  cacheKey = '',
+  fetchCall = () => Promise.resolve(),
+  onErrorHardCodedValue = undefined,
+}: GenerateCacheAPIFunctionProps) {
+  if (isCachePreferred) {
+    return await generateCacheAPIFunctionWithCachePreference(
+      cacheKey,
+      fetchCall,
+      onErrorHardCodedValue,
+    );
+  } else {
+    return await generateCacheAPIFunctionWithAPIPreference(
+      cacheKey,
+      fetchCall,
+      onErrorHardCodedValue,
+    );
+  }
+}
+
+async function generateCacheAPIFunctionWithCachePreference(
+  cacheKey: string,
+  fetchCall: (...props: any[]) => any,
+  onErrorHardCodedValue?: any,
+) {
+  try {
+    const response = (await Storage.getItem(cacheKey)) as string;
+
+    if (response) {
+      return JSON.parse(response);
+    } else {
+      const response = await fetchCall();
+
+      Storage.setItem(cacheKey, JSON.stringify(response)).then(() =>
+        console.log('Cached response for ' + cacheKey),
+      );
+
+      return response;
+    }
+  } catch (error) {
+    console.warn(`Failed to load due to network issue in cache preferred api call.
+     cache key:${cacheKey} and has onErrorHardCodedValue:${
+      onErrorHardCodedValue != undefined
+    }`);
+    console.log(error);
+
+    if (onErrorHardCodedValue != undefined) {
+      return onErrorHardCodedValue;
+    } else {
+      throw error;
+    }
+  }
+}
+
+async function generateCacheAPIFunctionWithAPIPreference(
+  cacheKey: string,
+  fetchCall: (...props: any[]) => any,
+  onErrorHardCodedValue?: any,
+) {
+  try {
+    const response = await fetchCall();
+    Storage.setItem(cacheKey, JSON.stringify(response)).then(() =>
+      console.log('Cached response for ' + cacheKey),
+    );
+    return response;
+  } catch (error) {
+    console.warn(`Failed to load due to network issue in API preferred api call.
+     cache key:${cacheKey} and has onErrorHardCodedValue:${
+      onErrorHardCodedValue != undefined
+    }`);
+
+    console.log(error);
+
+    const response = (await Storage.getItem(cacheKey)) as string;
+
+    if (response) {
+      return JSON.parse(response);
+    } else {
+      if (onErrorHardCodedValue != undefined) {
+        return onErrorHardCodedValue;
+      } else {
+        throw error;
+      }
+    }
+  }
+}