@webority-technologies/mobile-core 0.0.1

package/lib/module/api/userClient.js

@@ -0,0 +1,360 @@
+"use strict";
+
+import axios, { AxiosHeaders } from 'axios';
+import axiosRetry from 'axios-retry';
+import { getToken } from "../auth/authStore.js";
+import { getConfigValue } from "../config/index.js";
+import { Logger } from "../logger/index.js";
+import { getNetworkStatus } from "../network/networkStatus.js";
+
+// Define timeout for requests
+const REQUEST_TIMEOUT = 30000; // 30 seconds
+
+/**
+ * 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 class RequestOfflineError extends Error {
+  constructor(message = 'Request blocked: device is offline') {
+    super(message);
+    this.name = 'RequestOfflineError';
+  }
+}
+
+/**
+ * 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 const SESSION_TERMINATION_CODES = {
+  TERMINATED: 'SESSION_TERMINATED',
+  EXPIRED: 'SESSION_EXPIRED'
+};
+const TERMINATION_CODES = new Set(Object.values(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 const SESSION_INVALID_HEADER = 'x-security-stamp-invalid';
+const hasSessionInvalidHeader = headers => {
+  if (!headers || typeof headers !== 'object') {
+    return false;
+  }
+  const get = headers.get;
+  const raw = typeof get === 'function' ? get.call(headers, SESSION_INVALID_HEADER) : headers[SESSION_INVALID_HEADER];
+  return String(raw).toLowerCase() === 'true';
+};
+const getSessionTerminationCode = data => {
+  if (!data || typeof data !== 'object') {
+    return undefined;
+  }
+  const body = data;
+  const nested = body.error;
+  const candidates = [body.code, body.errorCode, nested && typeof nested === 'object' ? nested.code : undefined];
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && TERMINATION_CODES.has(candidate)) {
+      return candidate;
+    }
+  }
+  return undefined;
+};
+
+/**
+ * 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 => {
+    // Status-based ONLY — see publicClient for the reasoning. A bare network
+    // error carries no response, so it is not retried: the write may already
+    // have landed server-side, and this client issues non-idempotent requests.
+    const status = error.response?.status;
+    return typeof status === 'number' && (status === 429 || status >= 500 && status <= 599);
+  }
+});
+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 => {
+  // Reject before any network call when the device is known to be offline.
+  // Unknown connectivity (netinfo not installed, or undetermined) is treated
+  // as online — never block a request on an unavailable probe.
+  const network = await getNetworkStatus();
+  if (network.isConnected === false) {
+    Logger.warn(`Request blocked: device is offline. URL: ${config.url}`);
+    return Promise.reject(new RequestOfflineError());
+  }
+  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) {
+    const terminationCode = getSessionTerminationCode(axiosError.response.data) ?? (hasSessionInvalidHeader(axiosError.response.headers) ? SESSION_TERMINATION_CODES.TERMINATED : undefined);
+    if (terminationCode) {
+      // The session is dead server-side — a refresh would only burn a
+      // pointless round-trip, so go straight to logout.
+      Logger.warn(`Session ${terminationCode}, logging out without refresh. URL: ${originalRequest.url}`);
+      await requireStore().dispatch(authActions.logout());
+      return Promise.reject(error);
+    }
+    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

package/lib/module/auth/authStore.js

@@ -0,0 +1,148 @@
+"use strict";
+
+import { Logger } from "../logger/index.js";
+
+/**
+ * Token data persisted in the keychain.
+ */
+
+/**
+ * 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.
+ */
+
+let backend = null;
+let resolved = false;
+const resolveBackend = () => {
+  if (resolved) {
+    return backend;
+  }
+  resolved = true;
+  try {
+    const mod = require('react-native-keychain');
+    // Prefer named exports: the real module and the test mock both expose them
+    // flat, while `default` is a differently-shaped convenience object.
+    backend = typeof mod?.setInternetCredentials === 'function' ? mod : mod?.default;
+  } catch {
+    backend = null;
+  }
+  return backend;
+};
+const requireBackend = op => {
+  const b = resolveBackend();
+  if (!b) {
+    const err = new Error(`[authStore] react-native-keychain is not installed; cannot ${op}. ` + 'Install the peer dep or call setKeychainImplementation() with a custom backend.');
+    Logger.error(err.message);
+    throw err;
+  }
+  return b;
+};
+
+/**
+ * Inject a custom keychain backend at runtime.
+ * Pass `null` to reset to the default react-native-keychain backend.
+ */
+export const setKeychainImplementation = impl => {
+  backend = impl;
+  resolved = impl !== null;
+};
+
+/**
+ * Store token with expiry.
+ */
+export const storeToken = async (key, token, expiry) => {
+  // Never log the token or expiry values: Logger forwards to whatever remote
+  // sink the app wired (Crashlytics/Sentry), so a token here leaves the device.
+  Logger.info(`Storing token for key: ${key}`);
+  try {
+    const data = JSON.stringify({
+      token,
+      expiry
+    });
+    await requireBackend('store a token').setInternetCredentials(key, 'token', data, {
+      service: key
+    }); // Ensure service matches
+    Logger.info(`Token stored successfully for key: ${key}`);
+  } catch (error) {
+    // Log AND rethrow. Swallowing this told the caller the token was persisted
+    // when it was not, so an app would show a signed-in user holding a token
+    // that never reached the keychain — the session then dies at the next
+    // cold start with no failure anyone could have seen.
+    Logger.error(`Error storing token for key: ${key}`, error);
+    throw error;
+  }
+};
+
+/**
+ * Parse token data from credentials.
+ */
+const parseTokenData = credentials => {
+  if (!credentials) {
+    return null;
+  }
+  const {
+    password
+  } = credentials;
+  try {
+    const parsed = JSON.parse(password);
+    if (parsed && typeof parsed === 'object' && 'token' in parsed && 'expiry' in parsed && typeof parsed.token === 'string' && typeof parsed.expiry === 'string') {
+      return parsed;
+    }
+    return null;
+  } catch (error) {
+    Logger.error('Failed to parse token data', error);
+    return null;
+  }
+};
+
+/**
+ * Retrieve token and check if expired.
+ */
+export const getToken = async key => {
+  Logger.info(`Retrieving token for key: ${key}`);
+  try {
+    const credentials = await requireBackend('read a token').getInternetCredentials(key, {
+      service: key
+    }); // Ensure service matches
+    const parsedData = parseTokenData(credentials);
+    Logger.info(`Parsed token data for key: ${key}: ${parsedData ? 'present' : 'absent'}`);
+    if (!parsedData) {
+      Logger.warn(`Invalid or no token data found for key: ${key}`);
+      return null;
+    }
+    const {
+      token,
+      expiry
+    } = parsedData;
+    Logger.info(`Token retrieved for key: ${key}`);
+    return {
+      token,
+      expiry
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('Key permanently invalidated')) {
+      Logger.error(`Key permanently invalidated for key: ${key}. Clearing the invalidated key.`);
+      await removeToken(key); // Clear the invalidated key
+      return null;
+    }
+    Logger.error(`Error retrieving token for key: ${key}`, error);
+    return null;
+  }
+};
+
+/**
+ * Remove token by key.
+ */
+export const removeToken = async key => {
+  try {
+    await requireBackend('remove a token').resetInternetCredentials({
+      service: key
+    });
+    Logger.info(`Token removed successfully for key: ${key}`);
+  } catch (error) {
+    Logger.error(`Failed to remove token for key: ${key}`, error);
+  }
+};
+//# sourceMappingURL=authStore.js.map

package/lib/module/auth/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { getToken, removeToken, storeToken } from "./authStore.js";
+export { decodeJWT, getJWTExpiry, isJWTExpired } from "./jwt.js";
+//# sourceMappingURL=index.js.map

package/lib/module/auth/jwt.js

@@ -0,0 +1,82 @@
+"use strict";
+
+import { Logger } from "../logger/index.js";
+
+/**
+ * Standard claims plus arbitrary keys.
+ * `sub`, `exp`, `iat`, `nbf` follow RFC 7519 conventions.
+ */
+
+const base64UrlToBase64 = input => {
+  const padded = input + '='.repeat((4 - input.length % 4) % 4);
+  return padded.replace(/-/g, '+').replace(/_/g, '/');
+};
+const decodeBase64 = input => {
+  // RN runtimes expose `atob` (Hermes 0.71+); fall back to a Buffer-based decode otherwise.
+  if (typeof atob === 'function') {
+    return atob(input);
+  }
+  const {
+    Buffer
+  } = require('buffer');
+  return Buffer.from(input, 'base64').toString('utf-8');
+};
+const utf8FromBinary = binary => {
+  // Convert percent-encoded UTF-8 sequence so multi-byte chars survive.
+  try {
+    return decodeURIComponent(binary.split('').map(c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0')).join(''));
+  } catch {
+    return binary;
+  }
+};
+
+/**
+ * Decode a JWT's payload claims. Does **not** verify the signature.
+ *
+ * @returns claims object on success, `null` if the token is malformed.
+ */
+export const decodeJWT = token => {
+  if (!token || typeof token !== 'string') {
+    return null;
+  }
+  const parts = token.split('.');
+  if (parts.length !== 3) {
+    Logger.warn('[jwt] decodeJWT: token is not a valid JWT (expected 3 segments)');
+    return null;
+  }
+  try {
+    const payload = parts[1];
+    const json = utf8FromBinary(decodeBase64(base64UrlToBase64(payload)));
+    return JSON.parse(json);
+  } catch (error) {
+    Logger.warn('[jwt] decodeJWT failed to parse payload', error);
+    return null;
+  }
+};
+
+/**
+ * Returns true when the token is expired (or unparseable / missing `exp`).
+ *
+ * @param token JWT string
+ * @param leewaySeconds amount of clock-skew tolerance to apply (default 30s)
+ */
+export const isJWTExpired = (token, leewaySeconds = 30) => {
+  const claims = decodeJWT(token);
+  if (!claims || typeof claims.exp !== 'number') {
+    return true;
+  }
+  const nowSeconds = Math.floor(Date.now() / 1000);
+  return claims.exp <= nowSeconds + leewaySeconds;
+};
+
+/**
+ * Returns the token's expiry as a Date, or `null` when no `exp` claim exists.
+ */
+export const getJWTExpiry = token => {
+  const claims = decodeJWT(token);
+  if (!claims || typeof claims.exp !== 'number') {
+    return null;
+  }
+  return new Date(claims.exp * 1000);
+};
+//# sourceMappingURL=jwt.js.map

package/lib/module/config/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+/**
+ * Configuration management for Webority packages
+ * Provides a flexible way to inject configuration without hard dependencies
+ */
+
+const DEFAULT_CONFIG = {
+  baseUrl: null,
+  loggingEnabled: true,
+  logLevel: 'info',
+  environment: 'Development',
+  country: 'in',
+  appId: null,
+  appVersion: null
+};
+let globalConfig = {
+  ...DEFAULT_CONFIG
+};
+
+/**
+ * Set global configuration for all Webority packages
+ */
+export const setConfig = config => {
+  globalConfig = {
+    ...globalConfig,
+    ...config
+  };
+};
+
+/**
+ * Get current configuration
+ */
+export const getConfig = () => globalConfig;
+
+/**
+ * Get a specific config value with optional fallback.
+ * If the stored value is `null`, the fallback is returned (when provided).
+ */
+
+export function getConfigValue(key, fallback) {
+  const value = globalConfig[key];
+  if (value !== null) {
+    return value;
+  }
+  return fallback;
+}
+
+/**
+ * Reset configuration to defaults
+ */
+export const resetConfig = () => {
+  globalConfig = {
+    ...DEFAULT_CONFIG
+  };
+};
+//# sourceMappingURL=index.js.map