@goliapkg/sentori-react-native 4.0.0 → 5.0.0

package/src/state-snapshots.ts

@@ -1,133 +0,0 @@
-// v0.9.2 +S2 — State Time-travel (SDK side).
-//
-// `sentori.bindState({ redux, zustand })` subscribes to a store-like
-// object and records a shallow diff every time it emits a change.
-// A ring buffer of the last N snapshots travels with each
-// captureException as a `stateSnapshot` attachment — the dashboard's
-// time-travel viewer (v0.9.2.1) renders the timeline.
-//
-// Why diffs and not full snapshots:
-//   • prod stores can be huge (carts, paginated lists, etc.)
-//   • a diff drops to ~1% of full snapshot size in typical apps
-//   • the viewer rehydrates by applying diffs forward from a baseline
-//
-// `recordState(obj)` is the manual escape hatch for state that isn't
-// in a redux/zustand store (e.g. `useState` in a deeply-nested
-// component, or React Context). The host calls it where it makes sense.
-//
-// Privacy: the same mask query that protects screenshots is consulted
-// before serializing — any path matching `nativeID` shape isn't yet,
-// but `mask.matchPath` can be added later. v0.9.2 ships without
-// path masking; consumers should keep PII out of bindState scopes.
-
-const MAX_SNAPSHOTS = 50;
-
-type StoreLike = {
-  getState?: () => unknown;
-  subscribe?: (cb: () => void) => () => void;
-};
-
-export type StateSnapshot = {
-  /** Wall-clock when the diff fired. */
-  ts: number;
-  /** Top-level key/value diff vs the previous snapshot. Empty diff
-   *  doesn't get recorded. */
-  diff: Record<string, unknown>;
-  /** Source label so the viewer can show "Redux" / "Zustand" / "Manual". */
-  source: string;
-};
-
-let _snapshots: StateSnapshot[] = [];
-let _unsubscribers: (() => void)[] = [];
-let _lastByLabel: Record<string, unknown> = {};
-
-export function bindState(opts: {
-  redux?: StoreLike;
-  zustand?: StoreLike;
-  /** Additional named stores. The label is used as the snapshot's
-   *  `source` and as the diff bucket key. */
-  custom?: Record<string, StoreLike>;
-}): void {
-  unbindState();
-  bindOne('redux', opts.redux);
-  bindOne('zustand', opts.zustand);
-  if (opts.custom) {
-    for (const [label, store] of Object.entries(opts.custom)) {
-      bindOne(label, store);
-    }
-  }
-}
-
-function bindOne(label: string, store?: StoreLike): void {
-  if (!store) return;
-  if (typeof store.getState !== 'function' || typeof store.subscribe !== 'function') return;
-  try {
-    _lastByLabel[label] = store.getState();
-    const unsub = store.subscribe(() => {
-      const next = store.getState!();
-      const prev = _lastByLabel[label];
-      const diff = shallowDiff(prev, next);
-      if (diff && Object.keys(diff).length > 0) {
-        push({ diff, source: label, ts: Date.now() });
-      }
-      _lastByLabel[label] = next;
-    });
-    _unsubscribers.push(unsub);
-  } catch {
-    // ignore bad stores
-  }
-}
-
-export function unbindState(): void {
-  for (const u of _unsubscribers) {
-    try {
-      u();
-    } catch {
-      // ignore
-    }
-  }
-  _unsubscribers = [];
-  _lastByLabel = {};
-}
-
-/** Manual recording for state not in a subscribed store. */
-export function recordState(snapshot: Record<string, unknown>, source = 'manual'): void {
-  push({ diff: snapshot, source, ts: Date.now() });
-}
-
-export function getStateSnapshots(): StateSnapshot[] {
-  return _snapshots.slice();
-}
-
-export function clearStateSnapshots(): void {
-  _snapshots = [];
-}
-
-function push(s: StateSnapshot): void {
-  _snapshots.push(s);
-  while (_snapshots.length > MAX_SNAPSHOTS) _snapshots.shift();
-}
-
-/** Returns the top-level key/value diff (next has the value, prev
- *  may not contain the key). Empty diff returns `{}` so callers can
- *  no-op on empty. */
-export function shallowDiff(prev: unknown, next: unknown): null | Record<string, unknown> {
-  if (typeof next !== 'object' || next === null) return null;
-  const nObj = next as Record<string, unknown>;
-  if (typeof prev !== 'object' || prev === null) {
-    return { ...nObj };
-  }
-  const pObj = prev as Record<string, unknown>;
-  const out: Record<string, unknown> = {};
-  const keys = new Set([...Object.keys(pObj), ...Object.keys(nObj)]);
-  for (const k of keys) {
-    if (pObj[k] !== nObj[k]) out[k] = nObj[k];
-  }
-  return out;
-}
-
-/** Test-only. */
-export function __resetStateSnapshotsForTests(): void {
-  unbindState();
-  _snapshots = [];
-}

package/src/track.ts

@@ -1,123 +0,0 @@
-// v1.1 chunk B — analytics `track` events on the SDK side.
-//
-// `sentori.track(name, props?)` pushes a single typed analytics event
-// into a fixed-size ring. A timer flushes the ring every 30 s (or
-// when the buffer hits 500) to `POST /v1/track:batch`. Best-effort;
-// a flush failure drops the batch — analytics aren't critical
-// telemetry.
-//
-// Why not one fetch per event: a busy app emitting `$pageview` +
-// custom funnel events every nav would saturate the JS thread and
-// the host's outbound connection pool. The same batching shape the
-// metrics module uses keeps `track()` cheap to call from render
-// hooks.
-//
-// Auto-pageview (`$pageview`) is emitted from `useTraceNavigation`
-// in navigation.ts whenever react-navigation swaps the active route.
-// Hosts that don't use react-navigation can call
-// `sentori.track('$pageview', { route: 'Cart' })` themselves.
-
-import { addInternalBreadcrumb } from './breadcrumbs';
-import { getCurrentUserId } from './capture';
-import { getConfig, isInitialized } from './config';
-import { sendTrackBatch } from './transport';
-
-export type TrackProps = Record<string, unknown>;
-
-export type TrackEvent = {
-  environment?: string;
-  name: string;
-  props?: TrackProps;
-  release?: string;
-  route?: string;
-  sessionId?: string;
-  ts: string;
-  userId?: string;
-};
-
-const MAX_BUFFER = 500;
-const NAME_MAX = 200;
-const PROPS_KEYS_MAX = 40;
-const FLUSH_INTERVAL_MS = 30_000;
-
-let _buf: TrackEvent[] = [];
-let _timer: null | ReturnType<typeof setInterval> = null;
-
-/**
- * Record a typed analytics event. Cheap to call from render hooks —
- * pushes into a 500-slot ring drained every 30 s (or on overflow) by
- * the transport flusher.
- *
- * Reserved names start with `$` (e.g. `$pageview`) and are emitted by
- * the SDK itself; you can still call `track('$pageview', …)` from app
- * code to backfill routes the auto-instrumentation missed.
- *
- * Server caps: name ≤ 200 chars, ≤ 40 prop keys. Calls exceeding the
- * cap are dropped client-side (no throw) so app code can fire-and-
- * forget without try/catch.
- */
-export function track(name: string, props?: TrackProps, route?: string): void {
-  if (!isInitialized()) return;
-  if (typeof name !== 'string' || name.length === 0 || name.length > NAME_MAX) {
-    return;
-  }
-  if (props && Object.keys(props).length > PROPS_KEYS_MAX) {
-    return;
-  }
-  const config = getConfig();
-  const ev: TrackEvent = {
-    name,
-    props,
-    release: config?.release,
-    environment: config?.environment,
-    route,
-    ts: new Date().toISOString(),
-    userId: getCurrentUserId(),
-  };
-  _buf.push(ev);
-  // v2.0 W3 — auto-breadcrumb. When `init.capture.trackAutoBreadcrumb`
-  // is `true`, push a `{ type: 'track', data: { name, props } }`
-  // breadcrumb so the customer journey leading up to a later
-  // `captureException` / `captureMessage` is visible in the dashboard.
-  // Defaults off — see Config.trackAutoBreadcrumb docstring.
-  if (config?.trackAutoBreadcrumb === true) {
-    addInternalBreadcrumb('track', props ? { name, props } : { name });
-  }
-  if (_buf.length >= MAX_BUFFER) {
-    void flushTrack();
-  }
-}
-
-export async function flushTrack(): Promise<void> {
-  if (_buf.length === 0) return;
-  const config = getConfig();
-  if (!config) return;
-  const batch = _buf;
-  _buf = [];
-  await sendTrackBatch(config.ingestUrl, config.token, batch);
-}
-
-/**
- * Start the 30 s flush timer. Called once from `init()`. Idempotent.
- * `__resetTrackForTests` is exposed for vitest / bun:test teardown.
- */
-export function startTrackTimer(): void {
-  if (_timer !== null) return;
-  _timer = setInterval(() => {
-    void flushTrack();
-  }, FLUSH_INTERVAL_MS);
-  // Don't keep the process alive solely for this timer.
-  (_timer as unknown as { unref?: () => void }).unref?.();
-}
-
-export function __peekTrackBuffer(): readonly TrackEvent[] {
-  return _buf;
-}
-
-export function __resetTrackForTests(): void {
-  if (_timer !== null) {
-    clearInterval(_timer);
-    _timer = null;
-  }
-  _buf = [];
-}

package/src/trail.ts

@@ -1,32 +0,0 @@
-// Phase 46 — singleton TrailBuffer for the RN SDK.
-//
-// Kept in its own module so callers (including navigation.ts, which
-// is intentionally lightweight) can record steps without pulling in
-// capture.ts → handlers/screenshot.ts → react-native. The buffer is
-// drained inside capture.ts when an event captures and
-// `sessionTrailEnabled` is on.
-
-import { TrailBuffer, type TrailStep } from '@goliapkg/sentori-core';
-
-const _trail = new TrailBuffer(30);
-
-/**
- * Phase 46 — record a step into the session-trail buffer. The buffer
- * is a fixed-size FIFO (default 30 steps); pushing past capacity
- * drops the oldest entry. Steps are only uploaded if
- * `init({ capture: { sessionTrail: true } })` is on AND a
- * `captureException` follows.
- */
-export const captureStep = (label: string, opts?: Partial<TrailStep>): void => {
-  _trail.push({
-    ts: Date.now(),
-    label,
-    ...(opts ?? {}),
-  });
-};
-
-export const getTrailBuffer = (): TrailBuffer => _trail;
-
-export const __resetTrailForTests = (): void => {
-  _trail.clear();
-};

package/src/trust-score.ts

@@ -1,176 +0,0 @@
-// v1.1 chunk S3 — `sentori.queryTrustScore()` for the host app.
-//
-// Returns the device's current trust score (0–100, higher = healthier)
-// plus the per-kind signal mix that produced it. The host app uses
-// this to decide whether to step up authentication, decline a
-// purchase, or simply log a soft warning.
-//
-// Caching:
-//   L1 — process-memory, ~30 s. Same process should not re-fetch on
-//        every screen render; the score moves on a "minutes" cadence.
-//   L2 — install-id-derived AsyncStorage entry, ~5 minutes. Lets the
-//        host paint a cached score on cold start without waiting for
-//        the network. Stale entries are still served; the SDK
-//        re-fetches in the background.
-//
-// Fail-soft posture: if the network's down or the SDK isn't
-// initialised, returns the cached value (if any), else the safe
-// default (score = 100). The host should never see a thrown error
-// from this call — the score system is supposed to be invisible.
-
-import { isAnyNativeModuleLinked } from './native-loader';
-import { getConfig, isInitialized } from './config';
-import { getInstallId } from './install-id';
-
-const SDK_VERSION = '0.0.0';
-const STORAGE_KEY = '@sentori/trust-score';
-const L1_TTL_MS = 30_000;
-const L2_TTL_MS = 5 * 60_000;
-
-export type TrustSignal = {
-  count: number;
-  kind: string;
-  weight: number;
-};
-
-export type TrustScore = {
-  computedAt: string;
-  installId: string;
-  score: number;
-  signals: TrustSignal[];
-};
-
-type CacheEntry = { fetchedAt: number; score: TrustScore };
-
-type AsyncStorageLike = {
-  getItem: (key: string) => Promise<null | string>;
-  setItem: (key: string, value: string) => Promise<void>;
-};
-
-let _l1: null | CacheEntry = null;
-let _inflight: null | Promise<TrustScore> = null;
-
-function loadAsyncStorage(): AsyncStorageLike | null {
-  if (!isAnyNativeModuleLinked(['RNCAsyncStorage', 'AsyncStorageModule'])) return null;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const mod = require('@react-native-async-storage/async-storage') as {
-      default?: AsyncStorageLike;
-    };
-    return mod.default ?? (mod as unknown as AsyncStorageLike);
-  } catch {
-    return null;
-  }
-}
-
-function safeDefault(installId: string): TrustScore {
-  return {
-    computedAt: new Date().toISOString(),
-    installId,
-    score: 100,
-    signals: [],
-  };
-}
-
-async function readL2(): Promise<null | CacheEntry> {
-  const storage = loadAsyncStorage();
-  if (!storage) return null;
-  try {
-    const raw = await storage.getItem(STORAGE_KEY);
-    if (!raw) return null;
-    const parsed = JSON.parse(raw) as CacheEntry;
-    if (
-      typeof parsed?.fetchedAt !== 'number' ||
-      typeof parsed?.score?.score !== 'number'
-    ) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
-async function writeL2(entry: CacheEntry): Promise<void> {
-  const storage = loadAsyncStorage();
-  if (!storage) return;
-  try {
-    await storage.setItem(STORAGE_KEY, JSON.stringify(entry));
-  } catch {
-    // best-effort
-  }
-}
-
-async function fetchFresh(installId: string): Promise<TrustScore> {
-  const config = getConfig();
-  if (!config) return safeDefault(installId);
-  try {
-    const resp = await fetch(
-      `${config.ingestUrl}/v1/security/score?installId=${encodeURIComponent(installId)}`,
-      {
-        headers: {
-          Authorization: `Bearer ${config.token}`,
-          'Sentori-Sdk': `react-native/${SDK_VERSION}`,
-        },
-        method: 'GET',
-      }
-    );
-    if (!resp.ok) return safeDefault(installId);
-    const parsed = (await resp.json()) as TrustScore;
-    return parsed;
-  } catch {
-    return safeDefault(installId);
-  }
-}
-
-/**
- * Resolve the device's trust score. Always resolves — never throws,
- * never rejects. The two-layer cache means the first call after cold
- * start usually serves a < 1 ms result while a background refresh
- * keeps the value current.
- */
-export async function queryTrustScore(): Promise<TrustScore> {
-  if (!isInitialized()) {
-    const id = await getInstallId();
-    return safeDefault(id);
-  }
-  // L1 hit
-  const now = Date.now();
-  if (_l1 && now - _l1.fetchedAt < L1_TTL_MS) {
-    return _l1.score;
-  }
-  // Coalesce concurrent calls onto the same inflight fetch.
-  if (_inflight) return _inflight;
-
-  _inflight = (async () => {
-    try {
-      const installId = await getInstallId();
-      // L2 hit — serve immediately, kick off background refresh
-      const l2 = await readL2();
-      if (l2 && now - l2.fetchedAt < L2_TTL_MS && l2.score.installId === installId) {
-        _l1 = l2;
-        // background refresh (don't block caller)
-        void (async () => {
-          const fresh = await fetchFresh(installId);
-          const entry: CacheEntry = { fetchedAt: Date.now(), score: fresh };
-          _l1 = entry;
-          await writeL2(entry);
-        })();
-        return l2.score;
-      }
-      const fresh = await fetchFresh(installId);
-      const entry: CacheEntry = { fetchedAt: Date.now(), score: fresh };
-      _l1 = entry;
-      await writeL2(entry);
-      return fresh;
-    } finally {
-      _inflight = null;
-    }
-  })();
-  return _inflight;
-}
-
-export function __resetTrustScoreForTests(): void {
-  _l1 = null;
-  _inflight = null;
-}

package/src/types.ts

@@ -1,21 +0,0 @@
-// Phase 21: wire-format types moved to @goliapkg/sentori-core. Re-
-// exported here so existing relative imports keep working.
-
-export type {
-  App,
-  AttachmentKind,
-  AttachmentMeta,
-  AttachmentSource,
-  Breadcrumb,
-  BreadcrumbType,
-  CaptureExtras,
-  Device,
-  DeviceOS,
-  Event,
-  EventKind,
-  Frame,
-  Platform,
-  SentoriError,
-  Tags,
-  User,
-} from '@goliapkg/sentori-core'

package/src/uuid.ts

@@ -1,2 +0,0 @@
-// Phase 21: moved to @goliapkg/sentori-core.
-export { uuidV7 } from '@goliapkg/sentori-core'