@webority-technologies/mobile-core 0.0.1 → 0.0.2

package/lib/module/auth/authStore.js

@@ -1,38 +1,83 @@
 "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, the download module 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';
 
 /**
  * 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.
  */
+/**
+ * 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.
+ */
 
+// Only what a test or the showcase injected; null means use expo-secure-store.
 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;
+
+/**
+ * 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;
   }
-  return backend;
 };
+const resolveBackend = () => backend ?? expoSecureStoreBackend;
 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.');
+    const err = new Error(`[authStore] no secure-store backend available; cannot ${op}.`);
     Logger.error(err.message);
     throw err;
   }
@@ -40,12 +85,12 @@ const requireBackend = op => {
 };
 
 /**
- * Inject a custom keychain backend at runtime.
- * Pass `null` to reset to the default react-native-keychain backend.
+ * 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;
-  resolved = impl !== null;
 };
 
 /**
@@ -60,9 +105,9 @@ export const storeToken = async (key, token, expiry) => {
       token,
       expiry
     });
-    await requireBackend('store a token').setInternetCredentials(key, 'token', data, {
+    await requireBackend('store a token').setGenericPassword('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
@@ -90,8 +135,10 @@ const parseTokenData = credentials => {
       return parsed;
     }
     return null;
-  } catch (error) {
-    Logger.error('Failed to parse token data', error);
+  } 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;
   }
 };
@@ -100,31 +147,43 @@ const parseTokenData = credentials => {
  * 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, {
+    const credentials = await requireBackend('read a token').getGenericPassword({
       service: key
-    }); // Ensure service matches
+    });
+    // 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);
-    Logger.info(`Parsed token data for key: ${key}: ${parsedData ? 'present' : 'absent'}`);
     if (!parsedData) {
-      Logger.warn(`Invalid or no token data found for key: ${key}`);
+      // 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;
-    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
+    // 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);
@@ -137,11 +196,19 @@ export const getToken = async key => {
  */
 export const removeToken = async key => {
   try {
-    await requireBackend('remove a token').resetInternetCredentials({
+    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);
   }
 };

package/lib/module/auth/jwt.js

@@ -11,16 +11,40 @@ 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 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);
+    }
   }
-  const {
-    Buffer
-  } = require('buffer');
-  return Buffer.from(input, 'base64').toString('utf-8');
+  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 {

package/lib/module/config/index.js

@@ -12,7 +12,8 @@ const DEFAULT_CONFIG = {
   environment: 'Development',
   country: 'in',
   appId: null,
-  appVersion: null
+  appVersion: null,
+  logCurl: false
 };
 let globalConfig = {
   ...DEFAULT_CONFIG

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-technologies/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

package/lib/module/download/adapters/expoFs.js

@@ -0,0 +1,95 @@
+"use strict";
+
+/**
+ * expo-file-system. Shape verified against 57.0.6, where the legacy function
+ * API (`downloadAsync`, `getInfoAsync`) still exists on the main entry point
+ * but every one of those functions THROWS at runtime; they now live behind
+ * `expo-file-system/legacy`. This adapter therefore uses the class API only.
+ *
+ * The REQUIRE lives in the entry point beside this file, never here.
+ */
+
+/**
+ * expo reports a directory as a URI with a trailing slash, and the download
+ * module joins a directory to a file name with a `/` of its own.
+ */
+const asDirectoryPath = uri => uri.replace(/\/+$/, '');
+
+/**
+ * expo REJECTS a non-2xx download rather than resolving a status, and the two
+ * platforms word it differently: iOS "server returned HTTP 404", Android
+ * "HTTP 404", and the non-task download path "response has status: 404".
+ * Recovering the code is what lets the download module report `http-error` with
+ * a status rather than a bare `network` failure. A future wording change
+ * degrades to `network`, never to a wrong status.
+ */
+const HTTP_STATUS = /(?:HTTP|status)\s*:?\s*(\d{3})\b/i;
+const statusFrom = error => {
+  const message = error instanceof Error ? error.message : String(error);
+  const match = HTTP_STATUS.exec(message);
+  return match ? Number(match[1]) : undefined;
+};
+export const adaptExpoFileSystem = mod => {
+  const lib = mod?.default ?? mod;
+  if (typeof lib?.File !== 'function' || typeof lib.File.createDownloadTask !== 'function') {
+    return null;
+  }
+  const {
+    File,
+    Directory,
+    Paths
+  } = lib;
+  const documents = asDirectoryPath(Paths.document.uri);
+  return {
+    dirs: {
+      documents,
+      cache: asDirectoryPath(Paths.cache.uri),
+      // expo exposes no public Downloads directory, so a "downloads" request
+      // lands in the app's documents directory instead of the shared folder.
+      downloads: documents
+    },
+    download: ({
+      url,
+      path,
+      headers,
+      onProgress
+    }) => {
+      const task = File.createDownloadTask(url, new File(path), {
+        headers,
+        onProgress: onProgress ? progress => onProgress(progress.bytesWritten, progress.totalBytes) : undefined
+      });
+      return {
+        promise: task.downloadAsync().then(file => ({
+          bytes: file?.size
+        }), error => {
+          const status = statusFrom(error);
+          if (status === undefined) {
+            throw error;
+          }
+          return {
+            status
+          };
+        }),
+        cancel: () => task.cancel()
+      };
+    },
+    exists: path => Promise.resolve(new File(path).exists),
+    stat: path => Promise.resolve({
+      size: new File(path).size
+    }),
+    unlink: path => {
+      new File(path).delete();
+      return Promise.resolve();
+    },
+    // The download module calls this for a directory that usually already
+    // exists, so it must be idempotent rather than throw on the second run.
+    mkdir: path => {
+      new Directory(path).create({
+        intermediates: true,
+        idempotent: true
+      });
+      return Promise.resolve();
+    }
+  };
+};
+//# sourceMappingURL=expoFs.js.map

package/lib/module/download/adapters/shared.js

@@ -0,0 +1,8 @@
+"use strict";
+
+/** Coerce a driver-supplied size, which some report as a string. */
+export const asNumber = value => {
+  const n = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(n) ? n : 0;
+};
+//# sourceMappingURL=shared.js.map