@webority-technologies/mobile-core 0.0.1 → 0.0.3

package/lib/commonjs/logger/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.setRemoteLogger = exports.Logger = void 0;
+exports.setRemoteLogger = exports.setDeviceContext = exports.getDeviceContext = exports.configureLogger = exports.Logger = void 0;
 var _index = require("../config/index.js");
 // ANSI color codes
 const Colors = {
@@ -76,6 +76,139 @@ const toErrorObject = input => {
     return new Error(String(input));
   }
 };
+
+/**
+ * Device / app context attached once at boot (platform, OS version, app version,
+ * build number, device model, etc). Merged into every `recordError` context so
+ * every crash carries it without every call site repeating it.
+ */
+
+let deviceContext = null;
+const normalizeAttributeValue = value => {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  return String(value);
+};
+
+/**
+ * Set (or clear, with `null`) the device/app context merged into every
+ * `recordError` call. Each key is also forwarded to `remote.setAttribute`
+ * once, at the moment it is set.
+ */
+const setDeviceContext = context => {
+  deviceContext = context;
+  if (context) {
+    for (const [key, value] of Object.entries(context)) {
+      safe(() => remote?.setAttribute?.(key, normalizeAttributeValue(value)));
+    }
+  }
+};
+exports.setDeviceContext = setDeviceContext;
+const getDeviceContext = () => deviceContext;
+
+/** Tuning knobs for screen history and duplicate-error suppression. */
+exports.getDeviceContext = getDeviceContext;
+const DEFAULT_LOGGER_OPTIONS = {
+  dedupeWindowMs: 5000,
+  dedupeMaxPerWindow: 1,
+  screenHistoryLimit: 20
+};
+let loggerOptions = {
+  ...DEFAULT_LOGGER_OPTIONS
+};
+
+/** Configure dedupe window/threshold and screen history size. Merges with current options. */
+const configureLogger = options => {
+  loggerOptions = {
+    ...loggerOptions,
+    ...options
+  };
+  if (screenHistory.length > loggerOptions.screenHistoryLimit) {
+    screenHistory = screenHistory.slice(screenHistory.length - loggerOptions.screenHistoryLimit);
+  }
+};
+exports.configureLogger = configureLogger;
+let currentScreen = null;
+let screenHistory = [];
+const dedupeMap = new Map();
+const MAX_DEDUPE_ENTRIES = 200;
+const dedupeKeyFor = err => {
+  const firstFrame = err.stack?.split('\n')[1]?.trim();
+  return firstFrame ? `${err.message}::${firstFrame}` : err.message;
+};
+const capDedupeMap = () => {
+  while (dedupeMap.size > MAX_DEDUPE_ENTRIES) {
+    const oldestKey = dedupeMap.keys().next().value;
+    if (oldestKey === undefined) {
+      return;
+    }
+    dedupeMap.delete(oldestKey);
+  }
+};
+const shouldForward = key => {
+  if (loggerOptions.dedupeWindowMs <= 0) {
+    return {
+      forward: true
+    };
+  }
+  const now = Date.now();
+  const entry = dedupeMap.get(key);
+  if (!entry || now - entry.windowStart >= loggerOptions.dedupeWindowMs) {
+    const suppressedCount = entry?.suppressedCount ?? 0;
+    dedupeMap.set(key, {
+      windowStart: now,
+      count: 1,
+      suppressedCount: 0
+    });
+    capDedupeMap();
+    return suppressedCount > 0 ? {
+      forward: true,
+      suppressedCount
+    } : {
+      forward: true
+    };
+  }
+  entry.count += 1;
+  if (entry.count > loggerOptions.dedupeMaxPerWindow) {
+    entry.suppressedCount += 1;
+    return {
+      forward: false
+    };
+  }
+  return {
+    forward: true
+  };
+};
+const buildErrorContext = (context, suppressedCount) => {
+  const merged = {
+    ...deviceContext
+  };
+  if (currentScreen !== null) {
+    merged.screen = currentScreen;
+  }
+  if (suppressedCount) {
+    merged.suppressedCount = suppressedCount;
+  }
+  return {
+    ...merged,
+    ...context
+  };
+};
+const forwardErrorToRemote = (err, context) => {
+  const key = dedupeKeyFor(err);
+  const {
+    forward,
+    suppressedCount
+  } = shouldForward(key);
+  if (!forward) {
+    return;
+  }
+  safe(() => remote?.recordError?.(err, buildErrorContext(context, suppressedCount)));
+};
 const logInfo = (message, ...optionalParams) => {
   if (!isEnabled() || !isLogLevelAllowed(LogLevels.INFO.level)) {
     return;
@@ -100,10 +233,10 @@ const logError = (message, ...optionalParams) => {
   // First optional param is treated as the underlying error if it looks like one.
   const candidate = optionalParams[0];
   if (candidate !== undefined) {
-    safe(() => remote?.recordError?.(toErrorObject(candidate), {
+    forwardErrorToRemote(toErrorObject(candidate), {
       source: 'Logger.error',
       message
-    }));
+    });
   }
 };
 const breadcrumb = (message, data) => {
@@ -117,7 +250,7 @@ const recordError = (error, context) => {
   if (isEnabled() && isLogLevelAllowed('error')) {
     console.error(`${Colors.RED_BOLD}[RECORDED]: ${err.message}${Colors.RESET}`, context ?? '');
   }
-  safe(() => remote?.recordError?.(err, context));
+  forwardErrorToRemote(err, context);
 };
 const setUser = (id, attrs) => {
   safe(() => remote?.setUser?.(id, attrs));
@@ -125,6 +258,24 @@ const setUser = (id, attrs) => {
 const setAttribute = (key, value) => {
   safe(() => remote?.setAttribute?.(key, value));
 };
+
+/**
+ * Record the active screen as a breadcrumb and remember it for subsequent
+ * `recordError` context. Re-tracking the same screen name is a no-op.
+ */
+const trackScreen = (name, params) => {
+  if (name === currentScreen) {
+    return;
+  }
+  currentScreen = name;
+  screenHistory.push(name);
+  if (screenHistory.length > loggerOptions.screenHistoryLimit) {
+    screenHistory = screenHistory.slice(screenHistory.length - loggerOptions.screenHistoryLimit);
+  }
+  breadcrumb(`Screen: ${name}`, params);
+};
+const getCurrentScreen = () => currentScreen;
+const getScreenHistory = () => [...screenHistory];
 const Logger = exports.Logger = {
   info: logInfo,
   warn: logWarning,
@@ -132,6 +283,9 @@ const Logger = exports.Logger = {
   breadcrumb,
   recordError,
   setUser,
-  setAttribute
+  setAttribute,
+  trackScreen,
+  getCurrentScreen,
+  getScreenHistory
 };
 //# sourceMappingURL=index.js.map

package/lib/commonjs/network/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "getNetworkStatus", {
     return _networkStatus.getNetworkStatus;
   }
 });
+Object.defineProperty(exports, "setNetworkStatusImplementation", {
+  enumerable: true,
+  get: function () {
+    return _networkStatus.setNetworkStatusImplementation;
+  }
+});
 Object.defineProperty(exports, "useNetworkStatus", {
   enumerable: true,
   get: function () {

package/lib/commonjs/network/networkStatus.js

@@ -3,29 +3,64 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useNetworkStatus = exports.getNetworkStatus = exports.addNetworkStatusListener = void 0;
+exports.useNetworkStatus = exports.setNetworkStatusImplementation = exports.getNetworkStatus = exports.addNetworkStatusListener = void 0;
+var ExpoNetwork = _interopRequireWildcard(require("expo-network"));
 var _react = require("react");
 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); }
 const DEFAULT_STATUS = {
   isConnected: true,
   isInternetReachable: null,
   type: 'unknown'
 };
-let netInfo = null;
-let resolved = false;
-const resolveNetInfo = () => {
-  if (resolved) {
-    return netInfo;
-  }
-  resolved = true;
-  try {
-    const mod = require('@react-native-community/netinfo');
-    netInfo = mod.default ?? mod;
-  } catch {
-    _index.Logger.warn('[network] @react-native-community/netinfo is not installed; ' + 'useNetworkStatus() will report a default "online" status.');
-    netInfo = null;
+/**
+ * expo-network is imported directly, not resolved through a seam.
+ *
+ * `expo` is a REQUIRED peer of this package, so every consumer has the Expo
+ * modules by construction and the static-require problem that forced the old
+ * injection design does not arise. An app wires nothing: connectivity works
+ * because the library uses Expo, which is the point of the Expo-first policy.
+ * One backend also means one behaviour, rather than each app choosing.
+ */
+let override = null;
+
+/**
+ * Replace the backend. Intended for TESTS and for the showcase, which uses it
+ * to reach error paths that a healthy device never takes; it is not the way an
+ * app is meant to configure the library. Pass `null` to restore expo-network.
+ */
+const setNetworkStatusImplementation = impl => {
+  override = impl;
+};
+exports.setNetworkStatusImplementation = setNetworkStatusImplementation;
+const resolveNetInfo = () => override ?? expoNetworkBackend;
+
+/**
+ * expo-network in the shape this module already speaks.
+ *
+ * The conversion is not cosmetic: expo reports its type as an UPPERCASE enum
+ * where this module's vocabulary is lowercase, marks every field optional, and
+ * returns an EventSubscription where an unsubscribe function is expected.
+ */
+const expoNetworkBackend = {
+  fetch: async () => {
+    const state = await ExpoNetwork.getNetworkStateAsync();
+    return {
+      isConnected: state?.isConnected !== false,
+      isInternetReachable: state?.isInternetReachable ?? null,
+      type: state?.type ? String(state.type).toLowerCase() : undefined
+    };
+  },
+  addEventListener: cb => {
+    const subscription = ExpoNetwork.addNetworkStateListener(state => {
+      cb({
+        isConnected: state?.isConnected !== false,
+        isInternetReachable: state?.isInternetReachable ?? null,
+        type: state?.type ? String(state.type).toLowerCase() : undefined
+      });
+    });
+    return () => subscription.remove();
   }
-  return netInfo;
 };
 const normalize = state => {
   if (!state) {

package/lib/commonjs/permissions/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Permissions = void 0;
+exports.setPermissionsImplementation = exports.Permissions = void 0;
 var _reactNative = require("react-native");
 var _index = require("../logger/index.js");
 // Android only — legacy WRITE_EXTERNAL_STORAGE
@@ -24,6 +24,29 @@ const resolveModule = () => {
   }
   return permsModule;
 };
+
+/**
+ * Inject a custom permissions implementation at runtime.
+ * Pass `null` to reset to the default lazily-resolved native module.
+ *
+ * `resolved` goes FALSE on null, never true. Marking it resolved with a null
+ * backend would permanently disable permissions: the resolver short-circuits and the
+ * real module is never loaded again, which contradicts this function's own
+ * documented contract. That exact bug shipped once, in the storage seam.
+ *
+ * THIS MODULE IS THE EXPO-FIRST EXCEPTION, and deliberately keeps the old
+ * shape. Expo ships no permissions package: each module carries its own
+ * (expo-location's requestForegroundPermissionsAsync, expo-image-picker's, and
+ * so on), so there is no single object to adapt and the library must not guess
+ * which Expo modules an app installed. react-native-permissions stays, behind
+ * this module's own import path so an app that never asks for permissions
+ * never names the package to Metro.
+ */
+const setPermissionsImplementation = impl => {
+  permsModule = impl;
+  resolved = impl !== null;
+};
+exports.setPermissionsImplementation = setPermissionsImplementation;
 const mapToNative = kind => {
   const m = resolveModule();
   if (!m) {

package/lib/commonjs/sqlite/adapters/expo.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adaptExpoSqlite = void 0;
+/**
+ * expo-sqlite. Shape verified against 57.0.2 rather than assumed, and it is the
+ * one driver that cannot share an adapter with the others: expo splits reads
+ * from writes. `getAllAsync` yields rows but no change count, `runAsync` yields
+ * `{ changes, lastInsertRowId }` but no rows, and SqliteResultSet needs all
+ * three from one call. `prepareAsync` + `executeAsync` is the only call that
+ * returns both, so every statement goes through it rather than being routed by
+ * sniffing the SQL for a leading SELECT.
+ *
+ * The REQUIRE lives in the driver entry point beside this file, never here.
+ */
+
+const adaptExpoSqlite = mod => ({
+  // expo takes the directory as a third positional argument rather than an
+  // option, so `location` cannot be passed through the options object.
+  open: async (name, options) => {
+    const db = await mod.openDatabaseAsync(name, undefined, options?.location);
+    return {
+      execute: async (sql, params) => {
+        const statement = await db.prepareAsync(sql);
+        try {
+          const result = await statement.executeAsync(params ? [...params] : []);
+          // Safe on a write: expo returns [] when the statement produced no
+          // first row rather than stepping the statement a second time.
+          const rows = await result.getAllAsync();
+          return {
+            rows,
+            rowsAffected: result.changes,
+            // expo always reports lastInsertRowId, so unlike the other drivers
+            // this is never undefined. It is the connection's last insert rowid,
+            // which is only meaningful immediately after an INSERT.
+            insertId: result.lastInsertRowId
+          };
+        } finally {
+          // A statement left unfinalised holds a native handle for the life of
+          // the connection, and the core executes one per call.
+          await statement.finalizeAsync();
+        }
+      },
+      close: async () => {
+        await db.closeAsync();
+      }
+    };
+  }
+});
+exports.adaptExpoSqlite = adaptExpoSqlite;
+//# sourceMappingURL=expo.js.map

package/lib/commonjs/sqlite/adapters/op.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adaptOpSqlite = void 0;
+/**
+ * @op-engineering/op-sqlite. Shape verified against 18.1.4 rather than assumed:
+ * `open({ name, location })` is synchronous and returns a DB whose `execute` is
+ * ASYNC, and whose `rows` is already a plain array of objects rather than the
+ * `{ _array, item() }` shape the older drivers use. Both differences are why it
+ * cannot share the sync adapter.
+ *
+ * The REQUIRE lives in the driver entry point beside this file, never here.
+ */
+
+const adaptOpSqlite = mod => ({
+  open: async (name, options) => {
+    const db = mod.open({
+      name,
+      location: options?.location
+    });
+    return {
+      execute: async (sql, params) => {
+        const result = await db.execute(sql, params ? [...params] : undefined);
+        return {
+          rows: result.rows ?? [],
+          rowsAffected: result.rowsAffected ?? 0,
+          insertId: result.insertId
+        };
+      },
+      close: async () => {
+        if (db.closeAsync) {
+          await db.closeAsync();
+          return;
+        }
+        db.close();
+      }
+    };
+  }
+});
+exports.adaptOpSqlite = adaptOpSqlite;
+//# sourceMappingURL=op.js.map

package/lib/commonjs/sqlite/adapters/rows.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rowsToArray = void 0;
+/**
+ * Row shapes differ per driver: a plain array, `{ _array, length, item() }`, or
+ * `{ length, item() }` alone. Every adapter normalises to a plain array here so
+ * nothing driver-specific escapes into the Db layer.
+ */
+const rowsToArray = rows => {
+  if (Array.isArray(rows)) {
+    return rows;
+  }
+  const shaped = rows;
+  if (!shaped) {
+    return [];
+  }
+  if (Array.isArray(shaped._array)) {
+    return shaped._array;
+  }
+  if (typeof shaped.item === 'function' && typeof shaped.length === 'number') {
+    const out = [];
+    for (let i = 0; i < shaped.length; i += 1) {
+      out.push(shaped.item(i));
+    }
+    return out;
+  }
+  return [];
+};
+exports.rowsToArray = rowsToArray;
+//# sourceMappingURL=rows.js.map

package/lib/commonjs/sqlite/adapters/storage.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adaptSqliteStorage = void 0;
+var _rows = require("./rows.js");
+/** react-native-sqlite-storage: callback-based by default, promise-based once
+ * `enablePromise(true)` is called; `executeSql` resolves an array whose first
+ * element is the result set. */
+
+/**
+ * Adapt an already-required `react-native-sqlite-storage` module. Exported for
+ * the same reason as the filesystem adapters: the library cannot name a package
+ * the app did not install without breaking the app's bundle.
+ */
+const adaptSqliteStorage = mod => ({
+  open: async (name, options) => {
+    // This is a GLOBAL side effect, not a per-connection setting: the vendor
+    // implements it by rewriting SQLitePlugin and SQLiteFactory prototype
+    // methods. An app that also uses react-native-sqlite-storage directly in
+    // callback mode will find its own callbacks converted to promises from the
+    // moment this adapter opens a database. Unavoidable, since the adapter
+    // cannot work otherwise, and worth knowing before mixing the two.
+    mod.enablePromise(true);
+    const db = await mod.openDatabase({
+      name,
+      location: options?.location ?? 'default'
+    });
+    return {
+      execute: async (sql, params) => {
+        const [result] = await db.executeSql(sql, params ? [...params] : undefined);
+        return {
+          rows: (0, _rows.rowsToArray)(result.rows),
+          rowsAffected: result.rowsAffected ?? 0,
+          insertId: result.insertId
+        };
+      },
+      // Not `() => db.close()`: in promise mode this driver resolves the
+      // success-callback ARGUMENTS array rather than void, so returning it
+      // directly would make SqliteDatabase.close() resolve an array while
+      // typed as void. Awaiting and discarding makes the type honest.
+      close: async () => {
+        await db.close();
+      }
+    };
+  }
+});
+exports.adaptSqliteStorage = adaptSqliteStorage;
+//# sourceMappingURL=storage.js.map

package/lib/commonjs/sqlite/adapters/sync.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adaptSyncSqlite = void 0;
+var _rows = require("./rows.js");
+/**
+ * nitro-sqlite and quick-sqlite share one synchronous shape, so one adapter
+ * serves both. The REQUIRE lives in the driver entry points beside this file,
+ * never here and never in the core: Metro resolves requires statically, so a
+ * package named anywhere reachable becomes mandatory for every consumer.
+ */
+
+/** Shape shared by react-native-nitro-sqlite and react-native-quick-sqlite: a
+ * synchronous `open({ name, location })` whose `db.execute()` and `db.close()`
+ * are also synchronous. Both are wrapped in Promise.resolve to fit SqliteDriver. */
+
+/**
+ * Adapt an already-required nitro-sqlite or quick-sqlite module. Both expose the
+ * same synchronous shape. Exported so an app on quick-sqlite can inject it.
+ */
+const adaptSyncSqlite = mod => ({
+  open: async (name, options) => {
+    const db = mod.open({
+      name,
+      location: options?.location
+    });
+    return {
+      execute: async (sql, params) => {
+        const result = db.execute(sql, params ? [...params] : undefined);
+        return {
+          rows: (0, _rows.rowsToArray)(result.rows),
+          rowsAffected: result.rowsAffected ?? 0,
+          insertId: result.insertId
+        };
+      },
+      close: async () => {
+        db.close();
+      }
+    };
+  }
+});
+exports.adaptSyncSqlite = adaptSyncSqlite;
+//# sourceMappingURL=sync.js.map