@webority/mobile-core 0.0.23

package/lib/module/auth/authStore.js

@@ -0,0 +1,224 @@
+"use strict";
+
+import * as SecureStore from 'expo-secure-store';
+import { Logger } from "../logger/index.js";
+
+/**
+ * Token data persisted in the keychain.
+ */
+/**
+ * The two keys the library itself reads. Everything in the library that needs
+ * the bearer token, the HTTP client and the authenticated image cache,
+ * resolves it through these rather than repeating the literal, so
+ * one of them cannot silently drift and start reading a key nothing writes.
+ * Apps are free to store their own tokens under any other key.
+ */
+export const ACCESS_TOKEN_KEY = 'accessToken';
+export const REFRESH_TOKEN_KEY = 'refreshToken';
+
+/**
+ * The shape this module speaks to its store through. expo-secure-store is
+ * adapted to it below; an app or a test can supply anything else of this shape
+ * through `setKeychainImplementation`.
+ */
+/**
+ * The GENERIC password API, not the internet-credentials one.
+ *
+ * `kSecClassInternetPassword` exists for credentials bound to a server, protocol
+ * and port, and it integrates with Safari and AutoFill. A bearer token keyed by
+ * a name like "accessToken" is none of those things, and the library was only
+ * satisfying that API's required `server` argument by passing the key twice,
+ * once as the server and once as the service. That is misuse of the class.
+ *
+ * `kSecClassGenericPassword` is the class for app-local secrets, which is what a
+ * token is. It is what expo-secure-store uses underneath, and what the consumer
+ * app being migrated had already chosen for itself.
+ */
+/**
+ * The credential shape the seam reads back, declared here rather than imported
+ * from whichever package a consumer's backend comes from. A type-only import of
+ * a package this library does not declare survives into the published `.d.ts`,
+ * where a consumer that has not installed it either fails to typecheck or,
+ * under the RN template's `skipLibCheck: true`, loses all checking on these
+ * members with no signal. Any credential object with these three members
+ * satisfies it structurally.
+ */
+
+// Only what a test or the showcase injected; null means use expo-secure-store.
+let backend = null;
+
+/**
+ * expo-secure-store, adapted to the generic-password shape this module speaks.
+ *
+ * It is a flat key/value store, so the credential shape is reconstructed around
+ * it. The key is sanitised because expo rejects anything outside
+ * [A-Za-z0-9._-] at runtime, which would otherwise surface as a throw from deep
+ * inside the store rather than as a bad key.
+ */
+const keyFor = service => (service ?? 'default').replace(/[^A-Za-z0-9._-]/g, '_');
+const expoSecureStoreBackend = {
+  setGenericPassword: async (username, password, options) => {
+    await SecureStore.setItemAsync(keyFor(options?.service), JSON.stringify({
+      username,
+      password
+    }));
+    return true;
+  },
+  getGenericPassword: async options => {
+    const service = options?.service;
+    const raw = await SecureStore.getItemAsync(keyFor(service));
+    if (raw === null) {
+      return false;
+    }
+    const parsed = JSON.parse(raw);
+    return {
+      username: parsed.username,
+      password: parsed.password,
+      service: service ?? 'default'
+    };
+  },
+  resetGenericPassword: async options => {
+    await SecureStore.deleteItemAsync(keyFor(options?.service));
+    return true;
+  }
+};
+const resolveBackend = () => backend ?? expoSecureStoreBackend;
+const requireBackend = op => {
+  const b = resolveBackend();
+  if (!b) {
+    const err = new Error(`[authStore] no secure-store backend available; cannot ${op}.`);
+    Logger.error(err.message);
+    throw err;
+  }
+  return b;
+};
+
+/**
+ * Replace the secure-store backend. Intended for TESTS and for the showcase,
+ * which injects a failing store to demo the write-failure path; it is not how
+ * an app configures the library. Pass `null` to restore expo-secure-store.
+ */
+export const setKeychainImplementation = impl => {
+  backend = impl;
+};
+
+/**
+ * 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').setGenericPassword('token', data, {
+      service: key
+    });
+    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 {
+    // The single report for "stored, but not a token" belongs to getToken, which
+    // knows whether anything was stored at all. Logging here too made one event
+    // arrive twice, at two different levels.
+    return null;
+  }
+};
+
+/**
+ * Retrieve token and check if expired.
+ */
+export const getToken = async key => {
+  try {
+    const credentials = await requireBackend('read a token').getGenericPassword({
+      service: key
+    });
+    // Nothing stored is an ORDINARY state, not a fault: a signed-out user has no
+    // token, and every authenticated request, image and download asks for one.
+    // Warning here put three info lines and a warning into the log, and into the
+    // remote crash sink, on every one of those calls.
+    if (!credentials) {
+      return null;
+    }
+    const parsedData = parseTokenData(credentials);
+    if (!parsedData) {
+      // Something IS stored and it is not a token. That is corruption worth
+      // hearing about, and it is a different event from having no token.
+      Logger.warn(`Stored credentials for key "${key}" are not a valid token; ignoring them.`);
+      return null;
+    }
+    const {
+      token,
+      expiry
+    } = parsedData;
+    return {
+      token,
+      expiry
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    // Both spellings matter. Android throws "Key permanently invalidated" when
+    // the biometric enrolment changes; iOS throws "Secret invalidated" for the
+    // equivalent. Either way the stored value can never be decrypted again, so
+    // clearing it is the only way out: leaving it makes every later read fail
+    // identically, and the user is stuck with no route back to a login. A
+    // consumer app handled the iOS spelling and the library did not.
+    if (message.includes('Key permanently invalidated') || message.includes('Secret invalidated')) {
+      Logger.error(`Stored token for key "${key}" can no longer be decrypted; clearing it.`);
+      await removeToken(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').resetGenericPassword({
+      service: key
+    });
+    Logger.info(`Token removed successfully for key: ${key}`);
+  } catch (error) {
+    // Clearing a key that was never written is the ordinary logout path, not a
+    // failure: only one of the two tokens may ever have been stored. Logging it
+    // as an error puts routine traffic in the channel people watch for real
+    // problems, which is how an error channel stops being watched.
+    if (error instanceof Error && error.message.includes('Item not found')) {
+      Logger.info(`No token found to remove for key: ${key}`);
+      return;
+    }
+    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,106 @@
+"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 BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+/**
+ * Pure-JS base64, used only when the runtime has no `atob`.
+ *
+ * This used to be `require('buffer')`. That was a latent bundling failure for
+ * every consumer: `buffer` is a Node builtin that React Native does not
+ * provide, it was never declared as a dependency, and Metro resolves requires
+ * STATICALLY — so sitting inside an unreached fallback branch did not save it.
+ * The app still failed to bundle, with an error naming this file. It only went
+ * unnoticed because the repo's own checks never bundle for a device.
+ *
+ * Decoding four base64 characters yields three bytes; the padding tells us how
+ * many of those three are real.
+ */
+const decodeBase64Fallback = input => {
+  let out = '';
+  for (let i = 0; i < input.length; i += 4) {
+    const chunk = [0, 1, 2, 3].map(offset => BASE64_ALPHABET.indexOf(input[i + offset] ?? '='));
+    const bits = Math.max(chunk[0], 0) << 18 | Math.max(chunk[1], 0) << 12 | Math.max(chunk[2], 0) << 6 | Math.max(chunk[3], 0);
+    out += String.fromCharCode(bits >> 16 & 0xff);
+    if (chunk[2] !== -1) {
+      out += String.fromCharCode(bits >> 8 & 0xff);
+    }
+    if (chunk[3] !== -1) {
+      out += String.fromCharCode(bits & 0xff);
+    }
+  }
+  return out;
+};
+const decodeBase64 = input =>
+// Every RN runtime the library supports has `atob` (Hermes 0.71+), so the
+// fallback is a safety net rather than a path anyone is expected to take.
+typeof atob === 'function' ? atob(input) : decodeBase64Fallback(input);
+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,58 @@
+"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,
+  logCurl: false
+};
+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

package/lib/module/deepLink/index.js

@@ -0,0 +1,280 @@
+"use strict";
+
+import { useEffect, useRef } from 'react';
+import { Linking } from 'react-native';
+import { Logger } from "../logger/index.js";
+const PREFIX = '[@webority/mobile-core]';
+const decodeSafe = value => {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, ' '));
+  } catch {
+    return value;
+  }
+};
+const parseQuery = raw => {
+  const out = {};
+  if (!raw) {
+    return out;
+  }
+  for (const pair of raw.split('&')) {
+    if (!pair) {
+      continue;
+    }
+    const eq = pair.indexOf('=');
+    const key = decodeSafe(eq >= 0 ? pair.slice(0, eq) : pair);
+    if (!key) {
+      continue;
+    }
+    out[key] = eq >= 0 ? decodeSafe(pair.slice(eq + 1)) : '';
+  }
+  return out;
+};
+const trimSlashes = value => value.replace(/^\/+/, '').replace(/\/+$/, '');
+
+/**
+ * Parse a deep-link URL. Returns null for anything that is not a usable URL so
+ * a hostile or truncated link can never throw on the native event path.
+ */
+export const parseDeepLink = url => {
+  if (typeof url !== 'string') {
+    return null;
+  }
+  const trimmed = url.trim();
+  if (!trimmed || /\s/.test(trimmed)) {
+    return null;
+  }
+  const withoutFragment = trimmed.split('#')[0] ?? '';
+  const schemeEnd = withoutFragment.indexOf('://');
+  let scheme = '';
+  let rest = withoutFragment;
+  if (schemeEnd >= 0) {
+    const rawScheme = withoutFragment.slice(0, schemeEnd);
+    if (!/^[a-zA-Z][a-zA-Z0-9+.-]*$/.test(rawScheme)) {
+      return null;
+    }
+    scheme = rawScheme.toLowerCase();
+    rest = withoutFragment.slice(schemeEnd + 3);
+  }
+  const queryStart = rest.indexOf('?');
+  const rawPath = queryStart >= 0 ? rest.slice(0, queryStart) : rest;
+  const query = parseQuery(queryStart >= 0 ? rest.slice(queryStart + 1) : '');
+  let host = '';
+  let pathPart = rawPath;
+  if (scheme === 'http' || scheme === 'https') {
+    const slash = rawPath.indexOf('/');
+    host = slash >= 0 ? rawPath.slice(0, slash) : rawPath;
+    pathPart = slash >= 0 ? rawPath.slice(slash + 1) : '';
+  }
+  const path = trimSlashes(pathPart);
+  const segments = path ? path.split('/').filter(Boolean) : [];
+  if (scheme && scheme !== 'http' && scheme !== 'https') {
+    host = segments[0] ?? '';
+  }
+  return {
+    url: trimmed,
+    scheme,
+    host,
+    path,
+    segments,
+    query
+  };
+};
+const matchPattern = (pattern, segments) => {
+  const patternSegments = trimSlashes(pattern).split('/').filter(Boolean);
+  if (patternSegments.length !== segments.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i += 1) {
+    const p = patternSegments[i];
+    const s = segments[i];
+    if (p.startsWith(':')) {
+      const name = p.slice(1);
+      if (!name) {
+        return null;
+      }
+      params[name] = s;
+    } else if (p.toLowerCase() !== s.toLowerCase()) {
+      return null;
+    }
+  }
+  return params;
+};
+const matchRegExp = (pattern, path) => {
+  // A /g or /y pattern carries lastIndex between calls, so the same link would
+  // match on one dispatch and miss on the next.
+  if (pattern.global || pattern.sticky) {
+    pattern.lastIndex = 0;
+  }
+  const result = pattern.exec(path);
+  if (!result) {
+    return null;
+  }
+  const params = {};
+  for (let i = 1; i < result.length; i += 1) {
+    const group = result[i];
+    if (group !== undefined) {
+      params[String(i)] = group;
+    }
+  }
+  for (const [name, value] of Object.entries(result.groups ?? {})) {
+    if (value !== undefined) {
+      params[name] = value;
+    }
+  }
+  return params;
+};
+const matchRoute = (routes, link) => {
+  for (const route of routes) {
+    const params = typeof route.match === 'string' ? matchPattern(route.match, link.segments) : matchRegExp(route.match, link.path);
+    if (params) {
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return null;
+};
+let config = null;
+let subscription = null;
+let started = false;
+let pending = null;
+let readyOverride = null;
+const isReady = () => {
+  if (readyOverride !== null) {
+    return readyOverride;
+  }
+  return config?.isReady?.() ?? true;
+};
+const isAuthenticated = () => config?.isAuthenticated?.() ?? true;
+const dispatch = link => {
+  const active = config;
+  if (!active) {
+    return;
+  }
+  const matched = matchRoute(active.routes, link);
+  if (!matched) {
+    active.onUnmatched?.(link);
+    return;
+  }
+  if (matched.route.requiresAuth && !isAuthenticated()) {
+    pending = link;
+    active.onUnauthenticated?.(link);
+    return;
+  }
+  matched.route.handler(link, matched.params);
+};
+const flushPending = () => {
+  const link = pending;
+  if (!link) {
+    return;
+  }
+  // Cleared BEFORE dispatch: a handler that navigates can re-enter this path,
+  // and a link that fires twice is the classic deep-link duplicate-screen bug.
+  pending = null;
+  dispatch(link);
+};
+const configure = next => {
+  if (!next || !Array.isArray(next.routes)) {
+    throw new Error(`${PREFIX} DeepLink.configure() needs a config object with a "routes" array. ` + 'Pass { routes: [{ match: "order/:id", handler }] }.');
+  }
+  config = next;
+};
+const handleUrl = url => {
+  if (!config) {
+    Logger.error(`${PREFIX} DeepLink received a URL before configure() was called; the link was dropped. ` + 'Call DeepLink.configure({ routes }) (or useDeepLink) during app start.');
+    return;
+  }
+  const parsed = parseDeepLink(url);
+  // A malformed URL still reaches the app through onUnmatched, with the raw
+  // value in `url`, rather than vanishing.
+  if (!parsed) {
+    config.onUnmatched?.({
+      url: typeof url === 'string' ? url : '',
+      scheme: '',
+      host: '',
+      path: '',
+      segments: [],
+      query: {}
+    });
+    return;
+  }
+  const link = parsed;
+  if (!isReady()) {
+    pending = link;
+    return;
+  }
+  dispatch(link);
+};
+const start = async () => {
+  if (!config) {
+    throw new Error(`${PREFIX} DeepLink.start() was called before configure(). ` + 'Call DeepLink.configure({ routes }) first, or use the useDeepLink() hook.');
+  }
+  if (started) {
+    return;
+  }
+  started = true;
+  // Subscribe before reading the cold-start URL so a link arriving during the
+  // await is not lost.
+  subscription = Linking.addEventListener('url', event => {
+    handleUrl(event.url);
+  });
+  try {
+    const initial = await Linking.getInitialURL();
+    if (initial) {
+      handleUrl(initial);
+    }
+  } catch (error) {
+    Logger.error(`${PREFIX} DeepLink could not read the cold-start URL`, error);
+  }
+};
+const stop = () => {
+  subscription?.remove?.();
+  subscription = null;
+  started = false;
+  pending = null;
+  readyOverride = null;
+};
+const setReady = ready => {
+  readyOverride = ready;
+  if (ready) {
+    flushPending();
+  }
+};
+export const DeepLink = {
+  configure,
+  start,
+  stop,
+  handleUrl,
+  setReady,
+  /** Replay the stashed link, once. Call after a successful login. */
+  replayPending: flushPending,
+  getPending: () => pending
+};
+
+/**
+ * Configure and start the deep-link service for the lifetime of a component.
+ * The stored config delegates to the latest render, so new route closures do
+ * not tear down and re-subscribe the native listener.
+ */
+export const useDeepLink = deepLinkConfig => {
+  const configRef = useRef(deepLinkConfig);
+  configRef.current = deepLinkConfig;
+  useEffect(() => {
+    DeepLink.configure({
+      get routes() {
+        return configRef.current.routes;
+      },
+      isReady: () => configRef.current.isReady?.() ?? true,
+      isAuthenticated: () => configRef.current.isAuthenticated?.() ?? true,
+      onUnauthenticated: link => configRef.current.onUnauthenticated?.(link),
+      onUnmatched: link => configRef.current.onUnmatched?.(link)
+    });
+    void DeepLink.start();
+    return () => {
+      DeepLink.stop();
+    };
+  }, []);
+};
+//# sourceMappingURL=index.js.map