@webority-technologies/mobile 0.0.1

package/lib/commonjs/versionCheck/index.js

@@ -0,0 +1,338 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useVersionCheck = exports.default = exports.VersionCheck = void 0;
+var _reactNativeDeviceInfo = require("react-native-device-info");
+var _react = require("react");
+var _index = require("../config/index.js");
+var _index2 = require("../logger/index.js");
+// Constants
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 3000; // 3 seconds
+
+const getCountry = () => (0, _index.getConfigValue)('country', 'in').toLowerCase();
+// Utility function to parse and coerce version to a valid format
+const parseVersion = version => {
+  _index2.Logger.info(`Parsing version: ${version}`);
+  const coercedVersion = version.replace(/[^0-9.]/g, '');
+  const versionParts = coercedVersion.split('.').map(Number);
+  return {
+    major: versionParts[0] || 0,
+    minor: versionParts[1] || 0,
+    patch: versionParts[2] || 0,
+    prerelease: version.includes('-') ? version.split('-')[1] ?? '' : ''
+  };
+};
+
+// Utility function to compare two versions loosely
+const diffLoose = (version1, version2) => {
+  _index2.Logger.info(`Comparing versions: ${version1} and ${version2}`);
+  if (version1 === version2) {
+    return null;
+  }
+  const v1 = parseVersion(version1);
+  const v2 = parseVersion(version2);
+  if (v1.major < v2.major) {
+    return 'major';
+  }
+  if (v1.major > v2.major) {
+    return null;
+  }
+  if (v1.minor < v2.minor) {
+    return 'minor';
+  }
+  if (v1.minor > v2.minor) {
+    return null;
+  }
+  if (v1.patch < v2.patch) {
+    return 'patch';
+  }
+  if (v1.patch > v2.patch) {
+    return null;
+  }
+  if (v1.prerelease && !v2.prerelease) {
+    return 'prerelease';
+  }
+  if (!v1.prerelease && v2.prerelease) {
+    return null;
+  }
+  if (v1.prerelease < v2.prerelease) {
+    return 'prerelease';
+  }
+  if (v1.prerelease > v2.prerelease) {
+    return null;
+  }
+  return null;
+};
+
+// Function to compare current version with the latest version
+const versionCompare = (currentVersion, latestVersion) => {
+  _index2.Logger.info(`Comparing current version: ${currentVersion} with latest version: ${latestVersion}`);
+  if (!latestVersion) {
+    return {
+      needsUpdate: false,
+      updateType: null,
+      notice: 'Error: could not get latest version'
+    };
+  }
+  try {
+    const updateType = diffLoose(currentVersion, latestVersion);
+    return {
+      needsUpdate: !!updateType,
+      updateType
+    };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    _index2.Logger.error(`Error comparing versions: ${message}`);
+    const needsUpdate = currentVersion !== latestVersion && latestVersion > currentVersion;
+    const updateType = needsUpdate ? 'minor' : null;
+    return {
+      needsUpdate,
+      updateType,
+      notice: message.replace(/^Invalid Version:/, 'Not a valid version:')
+    };
+  }
+};
+
+// Function to fetch version details from Google Play Store
+const fetchAndroidVersion = async url => {
+  _index2.Logger.info(`Fetching Android version from URL: ${url}`);
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36',
+        'sec-fetch-site': 'same-origin'
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    _index2.Logger.error(`Error fetching data from Google Play Store: ${message}`);
+    throw new Error('Error fetching data from Google Play Store.');
+  }
+  if (!response.ok) {
+    if (response.status === 404) {
+      _index2.Logger.error('App with app ID not found in Google Play.');
+      throw new Error(`App with app ID not found in Google Play.`);
+    }
+    _index2.Logger.error(`Error fetching data: ${response.statusText}`);
+    throw new Error(response.statusText);
+  }
+  const text = await response.text();
+
+  // Primary regex pattern for current Play Store format
+  let versionMatch = text.match(/\[\[\[['"]((\d+\.)+\d+)['"]\]\],/);
+
+  // Alternate patterns as fallbacks
+  if (!versionMatch) {
+    // Fallback 1: Look for version in "current version" text
+    versionMatch = text.match(/Current Version[^\d]+((\d+\.)+\d+)/i);
+  }
+  if (!versionMatch) {
+    // Fallback 2: Look for itemprop="softwareVersion"
+    versionMatch = text.match(/itemprop="softwareVersion"[^>]*>((\d+\.)+\d+)</i);
+  }
+  if (!versionMatch) {
+    // Fallback 3: Try a more generic pattern for version numbers
+    const allVersions = text.match(/(\d+\.\d+(\.\d+)?)/g);
+    // If we found multiple version-like strings, use the first one
+    versionMatch = allVersions && allVersions.length > 0 ? [null, allVersions[0]] : null;
+  }
+  const version = versionMatch ? versionMatch[1] ?? null : null;
+  if (!version) {
+    _index2.Logger.warn('Could not extract version from Play Store. Using fallback method.');
+  }
+  const notesMatch = text.match(/<div itemprop="description">(.*?)<\/div>/);
+  const notes = notesMatch ? notesMatch[1] ?? '' : '';
+  return {
+    version,
+    releasedAt: new Date().toISOString(),
+    notes,
+    url,
+    lastChecked: new Date().toISOString()
+  };
+};
+// Function to fetch version details from Apple App Store
+const fetchIosVersion = async url => {
+  _index2.Logger.info(`Fetching iOS version from URL: ${url}`);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch {
+    _index2.Logger.error('Error connecting to iTunes.');
+    throw new Error('Error connecting to iTunes.');
+  }
+  const data = await response.json();
+  if (!data || !('results' in data)) {
+    _index2.Logger.error('Unknown error connecting to iTunes.');
+    throw new Error('Unknown error connecting to iTunes.');
+  }
+  if (!data.results.length) {
+    _index2.Logger.error('App for this bundle ID not found.');
+    throw new Error('App for this bundle ID not found.');
+  }
+  const result = data.results[0];
+  return {
+    version: result.version || null,
+    released: result.currentVersionReleaseDate || result.releaseDate || null,
+    notes: result.releaseNotes || '',
+    url: result.trackViewUrl || result.artistViewUrl || result.sellerUrl || null,
+    country: getCountry(),
+    lastChecked: new Date().toISOString()
+  };
+};
+
+// Function to lookup version based on platform
+const lookupVersion = async (platform, identifier) => {
+  _index2.Logger.info(`Looking up version for platform: ${platform}, identifier: ${identifier}`);
+  const country = getCountry();
+  const url = platform === 'ios' ? `https://itunes.apple.com/lookup?bundleId=${identifier}&country=${country}&_=${new Date().valueOf()}` : `https://play.google.com/store/apps/details?id=${identifier}&hl=${country}`;
+  return platform === 'ios' ? fetchIosVersion(url) : fetchAndroidVersion(url);
+};
+
+/**
+ * Check for new version with retry logic
+ */
+const checkForUpdates = async () => {
+  const platform = (0, _reactNativeDeviceInfo.getSystemName)().toLowerCase();
+  const identifier = (0, _reactNativeDeviceInfo.getBundleId)();
+  const currentVersion = (0, _reactNativeDeviceInfo.getVersion)();
+
+  // Implement retry mechanism
+  let retryCount = 0;
+  let lastError = null;
+  while (retryCount <= MAX_RETRIES) {
+    try {
+      _index2.Logger.info(`Checking if new version is available (attempt ${retryCount + 1}/${MAX_RETRIES + 1})`);
+      _index2.Logger.info(`Platform: ${platform}, identifier: ${identifier}, current version: ${currentVersion}`);
+      const latestVersionInfo = await lookupVersion(platform, identifier);
+      const comparison = versionCompare(currentVersion, latestVersionInfo.version);
+      return {
+        isNewVersionAvailable: comparison.needsUpdate,
+        updateType: comparison.updateType,
+        url: latestVersionInfo.url
+      };
+    } catch (error) {
+      lastError = error;
+      const message = error instanceof Error ? error.message : String(error);
+      _index2.Logger.error(`Error checking version (attempt ${retryCount + 1}/${MAX_RETRIES + 1}): ${message}`);
+
+      // If we've reached max retries, throw the last error
+      if (retryCount === MAX_RETRIES) {
+        throw error;
+      }
+
+      // Otherwise, wait and retry
+      retryCount++;
+      _index2.Logger.info(`Retrying version check in ${RETRY_DELAY}ms...`);
+      await new Promise(resolve => setTimeout(resolve, RETRY_DELAY));
+    }
+  }
+
+  // This should never be reached due to the throw above, but just in case
+  throw lastError instanceof Error ? lastError : new Error('Failed to check for updates after multiple attempts');
+};
+
+/**
+ * Get fallback store URL based on platform
+ */
+const getFallbackStoreUrl = () => {
+  const platform = (0, _reactNativeDeviceInfo.getSystemName)().toLowerCase();
+  const bundleId = (0, _reactNativeDeviceInfo.getBundleId)();
+  const country = getCountry();
+  return platform === 'ios' ? `https://apps.apple.com/${country}/app/${bundleId}` : `https://play.google.com/store/apps/details?id=${bundleId}&hl=${country}`;
+};
+// Version check functionality
+const VersionCheck = exports.VersionCheck = {
+  isNewVersionAvailable: async () => {
+    return checkForUpdates();
+  },
+  openUpdateUrl: async url => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const {
+      Linking
+    } = require('react-native');
+    try {
+      if (url) {
+        _index2.Logger.info(`Opening app store URL: ${url}`);
+        await Linking.openURL(url);
+      } else {
+        const fallbackUrl = getFallbackStoreUrl();
+        _index2.Logger.info(`Opening fallback store URL: ${fallbackUrl}`);
+        await Linking.openURL(fallbackUrl);
+      }
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      _index2.Logger.error(`Failed to open store URL: ${message}`);
+
+      // Try with fallback URL if the original failed
+      try {
+        if (url) {
+          // Only try fallback if we were using a specific URL before
+          const fallbackUrl = getFallbackStoreUrl();
+          _index2.Logger.info(`Trying fallback store URL: ${fallbackUrl}`);
+          await Linking.openURL(fallbackUrl);
+          return true;
+        }
+      } catch (fallbackError) {
+        const fbMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+        _index2.Logger.error(`Failed to open fallback URL: ${fbMessage}`);
+      }
+      return false;
+    }
+  },
+  getFallbackStoreUrl
+};
+
+/**
+ * Custom hook to check for required app updates.
+ *
+ * @param isAppReady - Whether the app is ready to perform the check
+ * @param environment - The app environment (defaults to the one in config)
+ */
+const useVersionCheck = (isAppReady, environment = (0, _index.getConfigValue)('environment', 'Development')) => {
+  const [updateInfo, setUpdateInfo] = (0, _react.useState)({
+    isUpdateRequired: false,
+    updateUrl: null
+  });
+  (0, _react.useEffect)(() => {
+    let isMounted = true;
+    const checkVersion = async () => {
+      try {
+        // All retry logic is handled in the VersionCheck module
+        const {
+          isNewVersionAvailable,
+          url
+        } = await VersionCheck.isNewVersionAvailable();
+        if (isNewVersionAvailable && isMounted) {
+          _index2.Logger.info('Update required. URL:', url || 'Not available yet');
+          setUpdateInfo({
+            isUpdateRequired: true,
+            updateUrl: url
+          });
+        } else if (isMounted) {
+          _index2.Logger.info('App is up to date');
+        }
+      } catch (error) {
+        _index2.Logger.error('Error checking app version:', error);
+      }
+    };
+
+    // Only run version check in Production environment when app is ready
+    if (isAppReady && environment === 'Production') {
+      void checkVersion();
+    }
+    return () => {
+      isMounted = false;
+    };
+  }, [isAppReady, environment]);
+  return updateInfo;
+};
+
+// Export for backward compatibility
+exports.useVersionCheck = useVersionCheck;
+var _default = exports.default = VersionCheck;
+//# sourceMappingURL=index.js.map

package/lib/module/api/publicClient.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import axios from 'axios';
+import axiosRetry from 'axios-retry';
+import { getConfigValue } from "../config/index.js";
+import { Logger } from "../logger/index.js";
+
+// Define timeout for requests
+const REQUEST_TIMEOUT = 30000; // 30 seconds
+
+/**
+ * Public Axios Client
+ * - Base URL: Set your public API base URL.
+ * - No Authorization header is attached.
+ * - Includes timeout configuration and error handling.
+ * - Handles specific HTTP status codes.
+ */
+const publicClient = axios.create({
+  baseURL: getConfigValue('baseUrl') ?? undefined,
+  headers: {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    'Accept-Encoding': 'gzip, deflate, br'
+  },
+  timeout: REQUEST_TIMEOUT
+});
+
+// Configure axios-retry with modified exponential backoff
+const retryConfig = {
+  retries: 3,
+  retryDelay: retryCount => retryCount === 0 ? 0 : Math.pow(2, retryCount) * 1000,
+  // Immediate retry for the first attempt
+  retryCondition: error => {
+    // Retry on network errors or specific status codes
+    return axiosRetry.isNetworkOrIdempotentRequestError(error) || [429, 503].includes(error.response?.status ?? 0);
+  }
+};
+axiosRetry(publicClient, retryConfig);
+
+// Add request interceptor for logging
+publicClient.interceptors.request.use(config => {
+  Logger.info(`Request: ${config.method?.toUpperCase()} ${config.url}`);
+  return config;
+}, error => {
+  const message = error instanceof Error ? error.message : String(error);
+  Logger.error('Request error:', message);
+  return Promise.reject(error);
+});
+
+// Add response interceptor for error handling
+publicClient.interceptors.response.use(response => {
+  Logger.info(`Response: ${response.status} from ${response.config.url}`);
+  return response;
+}, error => {
+  if (axios.isAxiosError(error)) {
+    const originalRequest = error.config;
+    if (!error.response) {
+      Logger.error(`Network error or no response from server: ${error.message}, URL: ${originalRequest?.url}`);
+    } else {
+      Logger.error(`Response error: ${error.response.data ?? error.message}, URL: ${originalRequest?.url}, Status: ${error.response.status}`);
+    }
+  } else {
+    const message = error instanceof Error ? error.message : String(error);
+    Logger.error(`Unknown response error: ${message}`);
+  }
+  return Promise.reject(error);
+});
+export default publicClient;
+//# sourceMappingURL=publicClient.js.map

package/lib/module/api/userClient.js

@@ -0,0 +1,283 @@
+"use strict";
+
+import axios, { AxiosHeaders } from 'axios';
+import axiosRetry, { isNetworkOrIdempotentRequestError } from 'axios-retry';
+import { Logger } from "../logger/index.js";
+import { getToken } from "../auth/authStore.js";
+import { getConfigValue } from "../config/index.js";
+// Define timeout for requests
+const REQUEST_TIMEOUT = 30000; // 30 seconds
+
+/**
+ * Minimal Redux-store shape required by the user client to dispatch
+ * refresh-token / logout actions.
+ */
+
+/**
+ * Internal extension of axios request config to track retry attempts.
+ */
+
+const userClient = axios.create({
+  baseURL: getConfigValue('baseUrl') ?? undefined,
+  headers: {
+    'Content-Type': 'application/json',
+    'Accept-Encoding': 'gzip, deflate, br'
+  },
+  timeout: REQUEST_TIMEOUT // Set timeout for all requests
+});
+
+// Configure axios-retry with modified exponential backoff
+axiosRetry(userClient, {
+  retries: 3,
+  retryDelay: retryCount => retryCount === 0 ? 0 : Math.pow(2, retryCount) * 1000,
+  // Immediate retry for the first attempt
+  retryCondition: error => {
+    // Retry on network errors or specific status codes
+    const status = error.response?.status;
+    return isNetworkOrIdempotentRequestError(error) ||
+    // Use the named export
+    typeof status === 'number' && [429, 503].includes(status);
+  }
+});
+let store;
+let authActions = {
+  logout: () => undefined,
+  refreshToken: () => undefined
+};
+export const injectStore = _store => {
+  store = _store;
+};
+export const injectAuthActions = actions => {
+  authActions = {
+    ...authActions,
+    ...actions
+  };
+};
+
+// Single promise to track token refresh
+let refreshTokenPromise = null;
+
+// Queue for failed requests
+let failedQueue = [];
+
+/**
+ * Processes the queue of failed requests.
+ */
+const processQueue = (error, token = null) => {
+  failedQueue.forEach(({
+    resolve,
+    reject
+  }) => {
+    if (error) {
+      reject(error);
+    } else if (token !== null) {
+      resolve(token);
+    }
+  });
+  failedQueue = [];
+};
+const getErrorMessage = error => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  return 'Unknown error';
+};
+const setAuthHeader = (config, token) => {
+  if (config.headers instanceof AxiosHeaders) {
+    config.headers.set('Authorization', `Bearer ${token}`);
+  } else {
+    // Fallback in case headers were provided as a plain object.
+    config.headers = AxiosHeaders.from({
+      ...config.headers,
+      Authorization: `Bearer ${token}`
+    });
+  }
+};
+const requireStore = () => {
+  if (!store) {
+    throw new Error('User package store is not initialized. Call initUserAuth first.');
+  }
+  return store;
+};
+
+/**
+ * Attach Authorization Token Before Requests
+ */
+userClient.interceptors.request.use(async config => {
+  try {
+    // Skip token check for refresh token endpoint to prevent infinite loop
+    if (config.url?.includes('/Account/RefreshToken')) {
+      return config;
+    }
+    const token = await getToken('accessToken');
+
+    // Check if token exists
+    if (!token?.token) {
+      throw new Error('No access token available');
+    }
+
+    // Check if token is expired
+    const currentTime = Date.now();
+    const tokenExpiry = Date.parse(token.expiry);
+    const bufferTime = 30 * 1000; // 30 seconds buffer
+
+    // If token is expired or about to expire, try to refresh it first
+    if (tokenExpiry <= currentTime + bufferTime) {
+      Logger.info('Access token expired or about to expire, refreshing before request');
+
+      // If we already have a refresh in progress, wait for it
+      if (refreshTokenPromise) {
+        Logger.info('Token refresh already in progress, waiting for completion');
+        try {
+          const newToken = await refreshTokenPromise;
+          setAuthHeader(config, newToken);
+          return config;
+        } catch (err) {
+          Logger.error('Failed to use refreshed token:', getErrorMessage(err));
+          throw err;
+        }
+      }
+
+      // Start a new token refresh process
+      refreshTokenPromise = (async () => {
+        try {
+          const refreshToken = await getToken('refreshToken');
+          if (!refreshToken?.token) {
+            Logger.error('No refresh token available');
+            throw new Error('No refresh token available');
+          }
+
+          // Check if refresh token is expired
+          const refreshTokenExpiry = Date.parse(refreshToken.expiry);
+          if (refreshTokenExpiry <= currentTime) {
+            Logger.error('Refresh token expired');
+            throw new Error('Refresh token expired');
+          }
+          Logger.info('Dispatching refresh token action');
+          const activeStore = requireStore();
+          const refreshResult = await activeStore.dispatch(authActions.refreshToken());
+          if (refreshResult.error) {
+            throw new Error(`Token refresh failed: ${refreshResult.error.message || 'Unknown error'}`);
+          }
+          const newAccessToken = await getToken('accessToken');
+          if (!newAccessToken?.token) {
+            throw new Error('Failed to retrieve new access token after refresh');
+          }
+          Logger.info('Token refreshed successfully before request');
+          return newAccessToken.token;
+        } catch (error) {
+          Logger.error('Token refresh failed before request:', getErrorMessage(error));
+          await requireStore().dispatch(authActions.logout());
+          throw error;
+        } finally {
+          refreshTokenPromise = null;
+        }
+      })();
+      try {
+        // Wait for the refresh to complete
+        const newToken = await refreshTokenPromise;
+        setAuthHeader(config, newToken);
+        return config;
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+
+    // Token is valid, proceed with request
+    setAuthHeader(config, token.token);
+    return config;
+  } catch (error) {
+    Logger.error('Failed to attach token:', getErrorMessage(error));
+    return Promise.reject(error);
+  }
+}, error => {
+  Logger.error('Request error:', getErrorMessage(error));
+  return Promise.reject(error);
+});
+
+/**
+ * Handle Response & Token Refresh
+ */
+userClient.interceptors.response.use(response => response, async error => {
+  if (!axios.isAxiosError(error)) {
+    Logger.error(`Non-axios error in response interceptor: ${getErrorMessage(error)}`);
+    return Promise.reject(error);
+  }
+  const axiosError = error;
+  const originalRequest = axiosError.config;
+  if (!axiosError.response) {
+    Logger.error(`Network error or no response from server: ${axiosError.message}, URL: ${originalRequest?.url}`);
+    return Promise.reject(error);
+  }
+  if (axiosError.response.status === 401 && originalRequest && !originalRequest._retry) {
+    Logger.warn(`Unauthorized URL: ${originalRequest.url}`);
+    originalRequest._retry = true;
+
+    // If we already have a refresh in progress, queue this request
+    if (refreshTokenPromise) {
+      return new Promise((resolve, reject) => {
+        failedQueue.push({
+          resolve,
+          reject
+        });
+      }).then(token => {
+        Logger.info('Retrying request after token refresh:', originalRequest.url);
+        setAuthHeader(originalRequest, token);
+        return userClient(originalRequest);
+      }).catch(err => {
+        Logger.error('Failed to retry request after token refresh:', getErrorMessage(err));
+        return Promise.reject(err);
+      });
+    }
+
+    // Start a new token refresh process and track it
+    refreshTokenPromise = (async () => {
+      try {
+        Logger.info('User Client: Refreshing token...');
+        const refreshToken = await getToken('refreshToken');
+        if (!refreshToken || !refreshToken.token) {
+          Logger.error('No refresh token available or token is invalid');
+          throw new Error('No refresh token available');
+        }
+        Logger.info('Dispatching refresh token action');
+        const activeStore = requireStore();
+        const refreshResult = await activeStore.dispatch(authActions.refreshToken());
+        if (refreshResult.error) {
+          Logger.error('Token refresh action failed:', refreshResult.error);
+          throw new Error(`Token refresh failed: ${refreshResult.error.message || 'Unknown error'}`);
+        }
+        Logger.info('Getting new access token after refresh');
+        const newAccessToken = await getToken('accessToken');
+        if (!newAccessToken?.token) {
+          throw new Error('Failed to retrieve new access token');
+        }
+        Logger.info('Token refreshed successfully');
+        processQueue(null, newAccessToken.token);
+        return newAccessToken.token;
+      } catch (refreshError) {
+        const responseData = axios.isAxiosError(refreshError) ? refreshError.response?.data : undefined;
+        Logger.error('Token refresh failed:', responseData ?? getErrorMessage(refreshError));
+        processQueue(refreshError, null);
+        await requireStore().dispatch(authActions.logout());
+        throw refreshError;
+      } finally {
+        refreshTokenPromise = null;
+      }
+    })();
+    try {
+      // Wait for the refresh token process to complete
+      const newToken = await refreshTokenPromise;
+      setAuthHeader(originalRequest, newToken);
+      return userClient(originalRequest);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  Logger.error(`Response error: ${axiosError.response?.data ?? axiosError.message}, URL: ${originalRequest?.url}, Status: ${axiosError.response.status}`);
+  return Promise.reject(error);
+});
+export default userClient;
+//# sourceMappingURL=userClient.js.map