@webority-technologies/mobile 0.0.1

package/lib/commonjs/api/userClient.js

@@ -0,0 +1,290 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.injectStore = exports.injectAuthActions = exports.default = void 0;
+var _axios = _interopRequireWildcard(require("axios"));
+var _axiosRetry = _interopRequireWildcard(require("axios-retry"));
+var _index = require("../logger/index.js");
+var _authStore = require("../auth/authStore.js");
+var _index2 = require("../config/index.js");
+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
+
+/**
+ * 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, _index2.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 => {
+    // Retry on network errors or specific status codes
+    const status = error.response?.status;
+    return (0, _axiosRetry.isNetworkOrIdempotentRequestError)(error) ||
+    // Use the named export
+    typeof status === 'number' && [429, 503].includes(status);
+  }
+});
+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 => {
+  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) {
+      _index.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) {
+        _index.Logger.info('Token refresh already in progress, waiting for completion');
+        try {
+          const newToken = await refreshTokenPromise;
+          setAuthHeader(config, newToken);
+          return config;
+        } catch (err) {
+          _index.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) {
+            _index.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) {
+            _index.Logger.error('Refresh token expired');
+            throw new Error('Refresh token expired');
+          }
+          _index.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');
+          }
+          _index.Logger.info('Token refreshed successfully before request');
+          return newAccessToken.token;
+        } catch (error) {
+          _index.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) {
+    _index.Logger.error('Failed to attach token:', getErrorMessage(error));
+    return Promise.reject(error);
+  }
+}, error => {
+  _index.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)) {
+    _index.Logger.error(`Non-axios error in response interceptor: ${getErrorMessage(error)}`);
+    return Promise.reject(error);
+  }
+  const axiosError = error;
+  const originalRequest = axiosError.config;
+  if (!axiosError.response) {
+    _index.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) {
+    _index.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 => {
+        _index.Logger.info('Retrying request after token refresh:', originalRequest.url);
+        setAuthHeader(originalRequest, token);
+        return userClient(originalRequest);
+      }).catch(err => {
+        _index.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 {
+        _index.Logger.info('User Client: Refreshing token...');
+        const refreshToken = await (0, _authStore.getToken)('refreshToken');
+        if (!refreshToken || !refreshToken.token) {
+          _index.Logger.error('No refresh token available or token is invalid');
+          throw new Error('No refresh token available');
+        }
+        _index.Logger.info('Dispatching refresh token action');
+        const activeStore = requireStore();
+        const refreshResult = await activeStore.dispatch(authActions.refreshToken());
+        if (refreshResult.error) {
+          _index.Logger.error('Token refresh action failed:', refreshResult.error);
+          throw new Error(`Token refresh failed: ${refreshResult.error.message || 'Unknown error'}`);
+        }
+        _index.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');
+        }
+        _index.Logger.info('Token refreshed successfully');
+        processQueue(null, newAccessToken.token);
+        return newAccessToken.token;
+      } catch (refreshError) {
+        const responseData = _axios.default.isAxiosError(refreshError) ? refreshError.response?.data : undefined;
+        _index.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);
+    }
+  }
+  _index.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,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.storeToken = exports.removeToken = exports.getToken = void 0;
+var Keychain = _interopRequireWildcard(require("react-native-keychain"));
+var _index = require("../logger/index.js");
+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); }
+/**
+ * Token data persisted in the keychain.
+ */
+
+/**
+ * Store token with expiry.
+ */
+const storeToken = async (key, token, expiry) => {
+  _index.Logger.info(`Storing token for key: ${key}, token: ${token}, expiry: ${expiry}`);
+  try {
+    const data = JSON.stringify({
+      token,
+      expiry
+    });
+    await Keychain.setInternetCredentials(key, 'token', data, {
+      service: key
+    }); // Ensure service matches
+    _index.Logger.info(`Token stored successfully for key: ${key}`);
+  } catch (error) {
+    _index.Logger.error(`Error storing token for key: ${key}`, 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 Keychain.getInternetCredentials(key, {
+      service: key
+    }); // Ensure service matches
+    const parsedData = parseTokenData(credentials);
+    _index.Logger.info(`Parsed token data for key: ${key}:`, parsedData);
+    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}, token: ${token}, expiry: ${expiry}`);
+    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 Keychain.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

package/lib/commonjs/auth/jwt.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isJWTExpired = exports.getJWTExpiry = exports.decodeJWT = void 0;
+var _index = require("../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);
+  }
+  /* eslint-disable @typescript-eslint/no-require-imports */
+  const {
+    Buffer
+  } = require('buffer');
+  /* eslint-enable */
+  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.
+ */
+const decodeJWT = token => {
+  if (!token || typeof token !== 'string') return null;
+  const parts = token.split('.');
+  if (parts.length !== 3) {
+    _index.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) {
+    _index.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)
+ */
+exports.decodeJWT = decodeJWT;
+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.
+ */
+exports.isJWTExpired = isJWTExpired;
+const getJWTExpiry = token => {
+  const claims = decodeJWT(token);
+  if (!claims || typeof claims.exp !== 'number') return null;
+  return new Date(claims.exp * 1000);
+};
+exports.getJWTExpiry = getJWTExpiry;
+//# sourceMappingURL=jwt.js.map