@webority-technologies/mobile-core 0.0.1

package/lib/module/validators/index.js

@@ -0,0 +1,171 @@
+"use strict";
+
+/**
+ * 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;
+};
+export const isNonEmpty = value => {
+  const s = asString(value);
+  return !!s && s.length > 0;
+};
+export 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
+ */
+export 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.
+ */
+export 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);
+};
+export 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;
+  }
+};
+export const isNumeric = value => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value);
+  }
+  const s = asString(value);
+  return !!s && RE_NUMERIC.test(s);
+};
+export const isInteger = value => {
+  if (typeof value === 'number') {
+    return Number.isInteger(value);
+  }
+  const s = asString(value);
+  return !!s && RE_INTEGER.test(s);
+};
+export const isAlphanumeric = value => {
+  const s = asString(value);
+  return !!s && RE_ALPHANUMERIC.test(s);
+};
+/**
+ * Common password complexity check. Defaults to 8+ chars,
+ * one uppercase, one lowercase, one digit.
+ */
+export 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;
+};
+export const isIndianPincode = value => {
+  const s = asString(value);
+  return !!s && RE_PINCODE_IN.test(s);
+};
+export const isPan = value => {
+  const s = asString(value);
+  return !!s && RE_PAN.test(s.toUpperCase());
+};
+export const isGstin = value => {
+  const s = asString(value);
+  return !!s && RE_GSTIN.test(s.toUpperCase());
+};
+export const isAadhaar = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  const digits = s.replace(/\s/g, '');
+  return RE_AADHAAR.test(digits);
+};
+export const isIfsc = value => {
+  const s = asString(value);
+  return !!s && RE_IFSC.test(s.toUpperCase());
+};
+export const isHexColor = value => {
+  const s = asString(value);
+  return !!s && RE_HEX_COLOR.test(s);
+};
+export 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;
+};
+export const minLength = (value, length) => {
+  const s = asString(value);
+  return !!s && s.length >= length;
+};
+export const maxLength = (value, length) => {
+  const s = asString(value);
+  return s == null ? true : s.length <= length;
+};
+//# sourceMappingURL=index.js.map

package/lib/module/versionCheck/index.js

@@ -0,0 +1,390 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+// Type-only — erased at compile time; react-native stays lazily required below.
+
+import { getConfigValue } from "../config/index.js";
+import { Logger } from "../logger/index.js";
+
+/**
+ * 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.
+ */
+export const setDeviceInfoImplementation = impl => {
+  deviceInfo = impl;
+};
+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.');
+  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 = getConfigValue('appId');
+  if (fromConfig) {
+    return fromConfig;
+  }
+  if (deviceInfo) {
+    return deviceInfo.getBundleId();
+  }
+  throw missing('store identifier', 'appId');
+};
+const getVersion = () => {
+  const fromConfig = 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 = () => getConfigValue('country', 'in').toLowerCase();
+// Utility function to parse and coerce version to a valid format
+const parseVersion = version => {
+  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) => {
+  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) => {
+  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);
+    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 => {
+  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);
+    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) {
+      Logger.error('App with app ID not found in Google Play.');
+      throw new Error(`App with app ID not found in Google Play.`);
+    }
+    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) {
+    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 => {
+  Logger.info(`Fetching iOS version from URL: ${url}`);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch {
+    Logger.error('Error connecting to iTunes.');
+    throw new Error('Error connecting to iTunes.');
+  }
+  const data = await response.json();
+  if (!data || !('results' in data)) {
+    Logger.error('Unknown error connecting to iTunes.');
+    throw new Error('Unknown error connecting to iTunes.');
+  }
+  if (!data.results.length) {
+    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) => {
+  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 {
+      Logger.info(`Checking if new version is available (attempt ${retryCount + 1}/${MAX_RETRIES + 1})`);
+      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);
+      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++;
+      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
+export const VersionCheck = {
+  isNewVersionAvailable: async () => {
+    return checkForUpdates();
+  },
+  openUpdateUrl: async url => {
+    const {
+      Linking
+    } = require('react-native');
+    try {
+      if (url) {
+        Logger.info(`Opening app store URL: ${url}`);
+        await Linking.openURL(url);
+      } else {
+        const fallbackUrl = getFallbackStoreUrl();
+        Logger.info(`Opening fallback store URL: ${fallbackUrl}`);
+        await Linking.openURL(fallbackUrl);
+      }
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      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();
+          Logger.info(`Trying fallback store URL: ${fallbackUrl}`);
+          await Linking.openURL(fallbackUrl);
+          return true;
+        }
+      } catch (fallbackError) {
+        const fbMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+        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)
+ */
+export const useVersionCheck = (isAppReady, environment = getConfigValue('environment', 'Development')) => {
+  const [updateInfo, setUpdateInfo] = useState({
+    isUpdateRequired: false,
+    updateUrl: null
+  });
+  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) {
+          Logger.info('Update required. URL:', url || 'Not available yet');
+          setUpdateInfo({
+            isUpdateRequired: true,
+            updateUrl: url
+          });
+        } else if (isMounted) {
+          Logger.info('App is up to date');
+        }
+      } catch (error) {
+        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
+export default VersionCheck;
+//# sourceMappingURL=index.js.map

package/lib/typescript/commonjs/api/publicClient.d.ts

@@ -0,0 +1,11 @@
+import { type AxiosInstance } from 'axios';
+/**
+ * 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.
+ */
+declare const publicClient: AxiosInstance;
+export default publicClient;
+//# sourceMappingURL=publicClient.d.ts.map

package/lib/typescript/commonjs/api/userClient.d.ts

@@ -0,0 +1,49 @@
+import { type AxiosInstance } from 'axios';
+import type { AuthActions } from '../initUserAuth';
+/**
+ * Thrown by the request interceptor when the device is offline, before the
+ * request ever reaches the adapter (and therefore the network). Distinct from
+ * an AxiosError so callers can show an offline message instead of a generic
+ * request failure.
+ */
+export declare class RequestOfflineError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Sub-codes a 401 response body carries when the session itself is dead
+ * (terminated by an admin, or expired server-side) rather than merely
+ * out-of-date. These never warrant a refresh attempt — only logout.
+ */
+export declare const SESSION_TERMINATION_CODES: {
+    readonly TERMINATED: "SESSION_TERMINATED";
+    readonly EXPIRED: "SESSION_EXPIRED";
+};
+export type SessionTerminationCode = (typeof SESSION_TERMINATION_CODES)[keyof typeof SESSION_TERMINATION_CODES];
+/**
+ * The header is the AUTHORITATIVE signal, verified against the backend:
+ * `WeborityJwtMiddleware.ReturnUnauthorized` answers an invalidated session with
+ * `401` + `X-Security-Stamp-Invalid: true` and a body of
+ * `{ error: 'Unauthorized', message: '...' }` — no code field at all, and
+ * `error` is a string rather than an object. An earlier version of this checked
+ * only body fields and would therefore never have fired against a real server.
+ *
+ * The body codes below are kept as a secondary path for any head that does send
+ * an explicit sub-code; they match on exact strings, so looking is free.
+ */
+export declare const SESSION_INVALID_HEADER = "x-security-stamp-invalid";
+/**
+ * Minimal Redux-store shape required by the user client to dispatch
+ * refresh-token / logout actions.
+ */
+export interface RefreshableStore {
+    dispatch: (action: unknown) => Promise<{
+        error?: {
+            message?: string;
+        };
+    }>;
+}
+declare const userClient: AxiosInstance;
+export declare const injectStore: <S>(_store: S) => void;
+export declare const injectAuthActions: (actions: AuthActions) => void;
+export default userClient;
+//# sourceMappingURL=userClient.d.ts.map

package/lib/typescript/commonjs/auth/authStore.d.ts

@@ -0,0 +1,43 @@
+import type * as KeychainModule from 'react-native-keychain';
+/**
+ * Token data persisted in the keychain.
+ */
+export interface StoredToken {
+    token: string;
+    expiry: string;
+}
+/**
+ * Minimal keychain shape we depend on.
+ * Lets us avoid a hard import on `react-native-keychain`, so an app that never
+ * stores a token does not have to install it.
+ */
+interface KeychainLike {
+    setInternetCredentials: (server: string, username: string, password: string, options?: {
+        service?: string;
+    }) => Promise<unknown>;
+    getInternetCredentials: (server: string, options?: {
+        service?: string;
+    }) => Promise<KeychainModule.UserCredentials | false>;
+    resetInternetCredentials: (options: {
+        service: string;
+    }) => Promise<unknown>;
+}
+/**
+ * Inject a custom keychain backend at runtime.
+ * Pass `null` to reset to the default react-native-keychain backend.
+ */
+export declare const setKeychainImplementation: (impl: KeychainLike | null) => void;
+/**
+ * Store token with expiry.
+ */
+export declare const storeToken: (key: string, token: string, expiry: string) => Promise<void>;
+/**
+ * Retrieve token and check if expired.
+ */
+export declare const getToken: (key: string) => Promise<StoredToken | null>;
+/**
+ * Remove token by key.
+ */
+export declare const removeToken: (key: string) => Promise<void>;
+export type { KeychainLike };
+//# sourceMappingURL=authStore.d.ts.map

package/lib/typescript/commonjs/auth/index.d.ts

@@ -0,0 +1,5 @@
+export type { StoredToken } from './authStore';
+export { getToken, removeToken, storeToken } from './authStore';
+export type { JwtClaims } from './jwt';
+export { decodeJWT, getJWTExpiry, isJWTExpired } from './jwt';
+//# sourceMappingURL=index.d.ts.map