@webority-technologies/mobile-core 0.0.1

package/lib/commonjs/validators/index.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.minLength = exports.maxLength = exports.isUrl = exports.isStrongPassword = exports.isPhone = exports.isPan = exports.isNumeric = exports.isNonEmpty = exports.isInteger = exports.isIndianPincode = exports.isIndianMobile = exports.isIfsc = exports.isHexColor = exports.isGstin = exports.isEmail = exports.isBetween = exports.isAlphanumeric = exports.isAadhaar = void 0;
+/**
+ * Generic validators returning `boolean`. All accept `null`/`undefined` safely.
+ *
+ * Tradeoff: regexes are pragmatic, not RFC-strict. They reject the things real users
+ * typo and accept the long tail of legitimate inputs. For RFC-grade validation use
+ * a dedicated library at the boundary.
+ */
+
+const RE_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const RE_INDIAN_MOBILE = /^[6-9]\d{9}$/;
+const RE_NUMERIC = /^-?\d+(?:\.\d+)?$/;
+const RE_INTEGER = /^-?\d+$/;
+const RE_ALPHANUMERIC = /^[a-zA-Z0-9]+$/;
+const RE_PINCODE_IN = /^[1-9]\d{5}$/;
+const RE_PAN = /^[A-Z]{5}\d{4}[A-Z]$/;
+const RE_GSTIN = /^\d{2}[A-Z]{5}\d{4}[A-Z][1-9A-Z]Z[0-9A-Z]$/;
+const RE_AADHAAR = /^\d{12}$/;
+const RE_IFSC = /^[A-Z]{4}0[A-Z0-9]{6}$/;
+const RE_HEX_COLOR = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const asString = v => {
+  if (typeof v === 'string') {
+    return v.trim();
+  }
+  return null;
+};
+const isNonEmpty = value => {
+  const s = asString(value);
+  return !!s && s.length > 0;
+};
+exports.isNonEmpty = isNonEmpty;
+const isEmail = value => {
+  const s = asString(value);
+  return !!s && RE_EMAIL.test(s);
+};
+
+/**
+ * Validate an Indian mobile number. Accepts:
+ * - 10-digit number starting with 6-9
+ * - Optional `+91` or `91` country code prefix
+ */
+exports.isEmail = isEmail;
+const isIndianMobile = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  const digits = s.replace(/\D/g, '');
+  const tail = digits.startsWith('91') && digits.length === 12 ? digits.slice(2) : digits;
+  return RE_INDIAN_MOBILE.test(tail);
+};
+
+/**
+ * Generic phone validator: 7–15 digits, optional `+` prefix.
+ * Use `isIndianMobile` when you specifically need an Indian mobile number.
+ */
+exports.isIndianMobile = isIndianMobile;
+const isPhone = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  const digits = s.replace(/[^\d+]/g, '').replace(/^\+/, '');
+  return digits.length >= 7 && digits.length <= 15 && /^\d+$/.test(digits);
+};
+exports.isPhone = isPhone;
+const isUrl = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  try {
+    // URL constructor is available on Hermes & JSC.
+
+    new URL(s);
+    return /^https?:\/\//i.test(s) || /^[a-z][a-z0-9+\-.]*:\/\//i.test(s);
+  } catch {
+    return false;
+  }
+};
+exports.isUrl = isUrl;
+const isNumeric = value => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value);
+  }
+  const s = asString(value);
+  return !!s && RE_NUMERIC.test(s);
+};
+exports.isNumeric = isNumeric;
+const isInteger = value => {
+  if (typeof value === 'number') {
+    return Number.isInteger(value);
+  }
+  const s = asString(value);
+  return !!s && RE_INTEGER.test(s);
+};
+exports.isInteger = isInteger;
+const isAlphanumeric = value => {
+  const s = asString(value);
+  return !!s && RE_ALPHANUMERIC.test(s);
+};
+exports.isAlphanumeric = isAlphanumeric;
+/**
+ * Common password complexity check. Defaults to 8+ chars,
+ * one uppercase, one lowercase, one digit.
+ */
+const isStrongPassword = (value, rules = {}) => {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  const {
+    minLength = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumber = true,
+    requireSymbol = false
+  } = rules;
+  if (value.length < minLength) {
+    return false;
+  }
+  if (requireUppercase && !/[A-Z]/.test(value)) {
+    return false;
+  }
+  if (requireLowercase && !/[a-z]/.test(value)) {
+    return false;
+  }
+  if (requireNumber && !/\d/.test(value)) {
+    return false;
+  }
+  if (requireSymbol && !/[^A-Za-z0-9]/.test(value)) {
+    return false;
+  }
+  return true;
+};
+exports.isStrongPassword = isStrongPassword;
+const isIndianPincode = value => {
+  const s = asString(value);
+  return !!s && RE_PINCODE_IN.test(s);
+};
+exports.isIndianPincode = isIndianPincode;
+const isPan = value => {
+  const s = asString(value);
+  return !!s && RE_PAN.test(s.toUpperCase());
+};
+exports.isPan = isPan;
+const isGstin = value => {
+  const s = asString(value);
+  return !!s && RE_GSTIN.test(s.toUpperCase());
+};
+exports.isGstin = isGstin;
+const isAadhaar = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  const digits = s.replace(/\s/g, '');
+  return RE_AADHAAR.test(digits);
+};
+exports.isAadhaar = isAadhaar;
+const isIfsc = value => {
+  const s = asString(value);
+  return !!s && RE_IFSC.test(s.toUpperCase());
+};
+exports.isIfsc = isIfsc;
+const isHexColor = value => {
+  const s = asString(value);
+  return !!s && RE_HEX_COLOR.test(s);
+};
+exports.isHexColor = isHexColor;
+const isBetween = (value, min, max, inclusive = true) => {
+  const n = typeof value === 'number' ? value : Number(asString(value));
+  if (!Number.isFinite(n)) {
+    return false;
+  }
+  return inclusive ? n >= min && n <= max : n > min && n < max;
+};
+exports.isBetween = isBetween;
+const minLength = (value, length) => {
+  const s = asString(value);
+  return !!s && s.length >= length;
+};
+exports.minLength = minLength;
+const maxLength = (value, length) => {
+  const s = asString(value);
+  return s == null ? true : s.length <= length;
+};
+exports.maxLength = maxLength;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/versionCheck/index.js

@@ -0,0 +1,395 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useVersionCheck = exports.setDeviceInfoImplementation = exports.default = exports.VersionCheck = void 0;
+var _react = require("react");
+var _index = require("../config/index.js");
+var _index2 = require("../logger/index.js");
+// Type-only — erased at compile time; react-native stays lazily required below.
+
+/**
+ * Minimal device-info shape we depend on.
+ *
+ * This is a LAST RESORT, not the primary path. `Platform.OS` already gives the
+ * platform, and every Webority app carries its own store id and version in
+ * `appsettings.Compiled.json` — so `setConfig({ appId, appVersion })` covers
+ * both remaining values without a native module. The injector below exists for
+ * apps that would rather hand us a `react-native-device-info` instance than
+ * wire two config keys.
+ */
+
+let deviceInfo = null;
+
+/**
+ * Supply the app identity from a native module instead of config.
+ * Prefer `setConfig({ appId, appVersion })` — it needs no native dependency.
+ * Pass `null` to clear.
+ */
+const setDeviceInfoImplementation = impl => {
+  deviceInfo = impl;
+};
+exports.setDeviceInfoImplementation = setDeviceInfoImplementation;
+const missing = (what, configKey) => {
+  const err = new Error(`[VersionCheck] the app's ${what} is not available. Call ` + `setConfig({ ${configKey}: '...' }) — every Webority app already has this value in ` + 'appsettings.Compiled.json — or setDeviceInfoImplementation() with a native provider.');
+  _index2.Logger.error(err.message);
+  return err;
+};
+
+// Platform comes from React Native itself; there has never been a reason to
+// cross a native module boundary for it.
+const getSystemName = () => {
+  const {
+    Platform
+  } = require('react-native');
+  return Platform.OS;
+};
+const getBundleId = () => {
+  const fromConfig = (0, _index.getConfigValue)('appId');
+  if (fromConfig) {
+    return fromConfig;
+  }
+  if (deviceInfo) {
+    return deviceInfo.getBundleId();
+  }
+  throw missing('store identifier', 'appId');
+};
+const getVersion = () => {
+  const fromConfig = (0, _index.getConfigValue)('appVersion');
+  if (fromConfig) {
+    return fromConfig;
+  }
+  if (deviceInfo) {
+    return deviceInfo.getVersion();
+  }
+  throw missing('version', 'appVersion');
+};
+
+// 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 = getSystemName().toLowerCase();
+  const identifier = getBundleId();
+  const currentVersion = 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 = getSystemName().toLowerCase();
+  const bundleId = 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 => {
+    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,76 @@
+"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 => {
+    // Status-based ONLY, deliberately: a bare network error must never be
+    // retried here. This client carries login and OTP, which are not
+    // idempotent — the request may well have reached the server before the
+    // connection broke, so a retry can create a second session the user never
+    // sees. axios-retry's isNetworkOrIdempotentRequestError does NOT protect
+    // against this: its isNetworkError branch never looks at the HTTP method,
+    // so it retried POSTs too.
+    const status = error.response?.status;
+    return typeof status === 'number' && (status === 429 || status >= 500 && status <= 599);
+  }
+};
+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