@webority-technologies/mobile-core 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# @webority-technologies/mobile-core
+
+The platform layer for Webority React Native apps: HTTP clients, auth and token storage, config,
+logging, formatters, validators, network status, permissions, storage, image compression and
+version checks. **No UI** — components live in
+[`@webority-technologies/mobile-ui`](https://www.npmjs.com/package/@webority-technologies/mobile-ui).
+
+```bash
+npm install @webority-technologies/mobile-core
+```
+
+External runtime dependencies: `axios` and `axios-retry`. Every native peer is optional and lazily
+required, so the package installs and runs without any of them.
+
+Full documentation lives in the repository's `docs/` directory.

package/lib/commonjs/api/publicClient.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+var _axiosRetry = _interopRequireDefault(require("axios-retry"));
+var _index = require("../config/index.js");
+var _index2 = require("../logger/index.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// 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.default.create({
+  baseURL: (0, _index.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);
+  }
+};
+(0, _axiosRetry.default)(publicClient, retryConfig);
+
+// Add request interceptor for logging
+publicClient.interceptors.request.use(config => {
+  _index2.Logger.info(`Request: ${config.method?.toUpperCase()} ${config.url}`);
+  return config;
+}, error => {
+  const message = error instanceof Error ? error.message : String(error);
+  _index2.Logger.error('Request error:', message);
+  return Promise.reject(error);
+});
+
+// Add response interceptor for error handling
+publicClient.interceptors.response.use(response => {
+  _index2.Logger.info(`Response: ${response.status} from ${response.config.url}`);
+  return response;
+}, error => {
+  if (_axios.default.isAxiosError(error)) {
+    const originalRequest = error.config;
+    if (!error.response) {
+      _index2.Logger.error(`Network error or no response from server: ${error.message}, URL: ${originalRequest?.url}`);
+    } else {
+      _index2.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);
+    _index2.Logger.error(`Unknown response error: ${message}`);
+  }
+  return Promise.reject(error);
+});
+var _default = exports.default = publicClient;
+//# sourceMappingURL=publicClient.js.map

package/lib/commonjs/api/userClient.js

@@ -0,0 +1,368 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.injectStore = exports.injectAuthActions = exports.default = exports.SESSION_TERMINATION_CODES = exports.SESSION_INVALID_HEADER = exports.RequestOfflineError = void 0;
+var _axios = _interopRequireWildcard(require("axios"));
+var _axiosRetry = _interopRequireDefault(require("axios-retry"));
+var _authStore = require("../auth/authStore.js");
+var _index = require("../config/index.js");
+var _index2 = require("../logger/index.js");
+var _networkStatus = require("../network/networkStatus.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+// 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.
+ */
+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.
+ */
+exports.RequestOfflineError = RequestOfflineError;
+const SESSION_TERMINATION_CODES = exports.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.
+ */
+const SESSION_INVALID_HEADER = exports.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.default.create({
+  baseURL: (0, _index.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
+(0, _axiosRetry.default)(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
+};
+const injectStore = _store => {
+  store = _store;
+};
+exports.injectStore = injectStore;
+const injectAuthActions = actions => {
+  authActions = {
+    ...authActions,
+    ...actions
+  };
+};
+
+// Single promise to track token refresh
+exports.injectAuthActions = injectAuthActions;
+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 _axios.AxiosHeaders) {
+    config.headers.set('Authorization', `Bearer ${token}`);
+  } else {
+    // Fallback in case headers were provided as a plain object.
+    config.headers = _axios.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 (0, _networkStatus.getNetworkStatus)();
+  if (network.isConnected === false) {
+    _index2.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 (0, _authStore.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) {
+      _index2.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) {
+        _index2.Logger.info('Token refresh already in progress, waiting for completion');
+        try {
+          const newToken = await refreshTokenPromise;
+          setAuthHeader(config, newToken);
+          return config;
+        } catch (err) {
+          _index2.Logger.error('Failed to use refreshed token:', getErrorMessage(err));
+          throw err;
+        }
+      }
+
+      // Start a new token refresh process
+      refreshTokenPromise = (async () => {
+        try {
+          const refreshToken = await (0, _authStore.getToken)('refreshToken');
+          if (!refreshToken?.token) {
+            _index2.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) {
+            _index2.Logger.error('Refresh token expired');
+            throw new Error('Refresh token expired');
+          }
+          _index2.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 (0, _authStore.getToken)('accessToken');
+          if (!newAccessToken?.token) {
+            throw new Error('Failed to retrieve new access token after refresh');
+          }
+          _index2.Logger.info('Token refreshed successfully before request');
+          return newAccessToken.token;
+        } catch (error) {
+          _index2.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) {
+    _index2.Logger.error('Failed to attach token:', getErrorMessage(error));
+    return Promise.reject(error);
+  }
+}, error => {
+  _index2.Logger.error('Request error:', getErrorMessage(error));
+  return Promise.reject(error);
+});
+
+/**
+ * Handle Response & Token Refresh
+ */
+userClient.interceptors.response.use(response => response, async error => {
+  if (!_axios.default.isAxiosError(error)) {
+    _index2.Logger.error(`Non-axios error in response interceptor: ${getErrorMessage(error)}`);
+    return Promise.reject(error);
+  }
+  const axiosError = error;
+  const originalRequest = axiosError.config;
+  if (!axiosError.response) {
+    _index2.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.
+      _index2.Logger.warn(`Session ${terminationCode}, logging out without refresh. URL: ${originalRequest.url}`);
+      await requireStore().dispatch(authActions.logout());
+      return Promise.reject(error);
+    }
+    _index2.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 => {
+        _index2.Logger.info('Retrying request after token refresh:', originalRequest.url);
+        setAuthHeader(originalRequest, token);
+        return userClient(originalRequest);
+      }).catch(err => {
+        _index2.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 {
+        _index2.Logger.info('User Client: Refreshing token...');
+        const refreshToken = await (0, _authStore.getToken)('refreshToken');
+        if (!refreshToken || !refreshToken.token) {
+          _index2.Logger.error('No refresh token available or token is invalid');
+          throw new Error('No refresh token available');
+        }
+        _index2.Logger.info('Dispatching refresh token action');
+        const activeStore = requireStore();
+        const refreshResult = await activeStore.dispatch(authActions.refreshToken());
+        if (refreshResult.error) {
+          _index2.Logger.error('Token refresh action failed:', refreshResult.error);
+          throw new Error(`Token refresh failed: ${refreshResult.error.message || 'Unknown error'}`);
+        }
+        _index2.Logger.info('Getting new access token after refresh');
+        const newAccessToken = await (0, _authStore.getToken)('accessToken');
+        if (!newAccessToken?.token) {
+          throw new Error('Failed to retrieve new access token');
+        }
+        _index2.Logger.info('Token refreshed successfully');
+        processQueue(null, newAccessToken.token);
+        return newAccessToken.token;
+      } catch (refreshError) {
+        const responseData = _axios.default.isAxiosError(refreshError) ? refreshError.response?.data : undefined;
+        _index2.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);
+    }
+  }
+  _index2.Logger.error(`Response error: ${axiosError.response?.data ?? axiosError.message}, URL: ${originalRequest?.url}, Status: ${axiosError.response.status}`);
+  return Promise.reject(error);
+});
+var _default = exports.default = userClient;
+//# sourceMappingURL=userClient.js.map

package/lib/commonjs/auth/authStore.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.storeToken = exports.setKeychainImplementation = exports.removeToken = exports.getToken = void 0;
+var _index = require("../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.');
+    _index.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.
+ */
+const setKeychainImplementation = impl => {
+  backend = impl;
+  resolved = impl !== null;
+};
+
+/**
+ * Store token with expiry.
+ */
+exports.setKeychainImplementation = setKeychainImplementation;
+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.
+  _index.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
+    _index.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.
+    _index.Logger.error(`Error storing token for key: ${key}`, error);
+    throw error;
+  }
+};
+
+/**
+ * Parse token data from credentials.
+ */
+exports.storeToken = storeToken;
+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) {
+    _index.Logger.error('Failed to parse token data', error);
+    return null;
+  }
+};
+
+/**
+ * Retrieve token and check if expired.
+ */
+const getToken = async key => {
+  _index.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);
+    _index.Logger.info(`Parsed token data for key: ${key}: ${parsedData ? 'present' : 'absent'}`);
+    if (!parsedData) {
+      _index.Logger.warn(`Invalid or no token data found for key: ${key}`);
+      return null;
+    }
+    const {
+      token,
+      expiry
+    } = parsedData;
+    _index.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')) {
+      _index.Logger.error(`Key permanently invalidated for key: ${key}. Clearing the invalidated key.`);
+      await removeToken(key); // Clear the invalidated key
+      return null;
+    }
+    _index.Logger.error(`Error retrieving token for key: ${key}`, error);
+    return null;
+  }
+};
+
+/**
+ * Remove token by key.
+ */
+exports.getToken = getToken;
+const removeToken = async key => {
+  try {
+    await requireBackend('remove a token').resetInternetCredentials({
+      service: key
+    });
+    _index.Logger.info(`Token removed successfully for key: ${key}`);
+  } catch (error) {
+    _index.Logger.error(`Failed to remove token for key: ${key}`, error);
+  }
+};
+exports.removeToken = removeToken;
+//# sourceMappingURL=authStore.js.map

package/lib/commonjs/auth/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "decodeJWT", {
+  enumerable: true,
+  get: function () {
+    return _jwt.decodeJWT;
+  }
+});
+Object.defineProperty(exports, "getJWTExpiry", {
+  enumerable: true,
+  get: function () {
+    return _jwt.getJWTExpiry;
+  }
+});
+Object.defineProperty(exports, "getToken", {
+  enumerable: true,
+  get: function () {
+    return _authStore.getToken;
+  }
+});
+Object.defineProperty(exports, "isJWTExpired", {
+  enumerable: true,
+  get: function () {
+    return _jwt.isJWTExpired;
+  }
+});
+Object.defineProperty(exports, "removeToken", {
+  enumerable: true,
+  get: function () {
+    return _authStore.removeToken;
+  }
+});
+Object.defineProperty(exports, "storeToken", {
+  enumerable: true,
+  get: function () {
+    return _authStore.storeToken;
+  }
+});
+var _authStore = require("./authStore.js");
+var _jwt = require("./jwt.js");
+//# sourceMappingURL=index.js.map