@goliapkg/sentori-react-native 2.1.0 → 3.0.0

package/src/__tests__/compat-sentry.test.ts

@@ -0,0 +1,121 @@
+/**
+ * v2.3 W6.3 — Sentry-compat translation layer coverage.
+ *
+ * We exercise the pure-function pieces directly via the test hooks
+ * exported from the compat module (parseDsn, mapCategoryToType,
+ * mapLevel). The stateful pieces — init / captureException /
+ * setUser dispatching to the native init + scope — are covered by
+ * the upstream Sentori-native tests (sdk.test, before-send.test);
+ * the compat layer only re-shapes the call arguments before
+ * delegating, so testing the re-shape is enough.
+ */
+import { describe, expect, test } from 'bun:test';
+
+import {
+  __mapCategoryToTypeForTests,
+  __mapLevelForTests,
+  __parseDsnForTests,
+  Severity,
+} from '../compat/sentry';
+
+describe('parseDsn', () => {
+  test('extracts token + ingestUrl from a Sentori DSN', () => {
+    const r = __parseDsnForTests(
+      'https://st_pk_testabcdef@ingest.sentori.golia.jp/1',
+    );
+    expect(r.token).toBe('st_pk_testabcdef');
+    expect(r.ingestUrl).toBe('https://ingest.sentori.golia.jp');
+  });
+
+  test('honours custom port + host', () => {
+    const r = __parseDsnForTests('https://st_pk_x@self-hosted.example.com:8443/42');
+    expect(r.token).toBe('st_pk_x');
+    expect(r.ingestUrl).toBe('https://self-hosted.example.com:8443');
+  });
+
+  test('rejects non-Sentori token prefix with a clear pointer', () => {
+    expect(() =>
+      __parseDsnForTests('https://abcd1234@sentry.io/12345'),
+    ).toThrow(/st_pk_/);
+  });
+
+  test('rejects DSN without user-info (no token)', () => {
+    expect(() => __parseDsnForTests('https://sentry.io/12345')).toThrow();
+  });
+
+  test('rejects malformed URL', () => {
+    expect(() => __parseDsnForTests('not-a-url')).toThrow(/not a valid URL/);
+  });
+});
+
+describe('mapCategoryToType', () => {
+  test('user-interaction categories → user', () => {
+    for (const c of ['auth', 'click', 'gesture', 'input', 'touch', 'ui']) {
+      expect(__mapCategoryToTypeForTests(c)).toBe('user');
+    }
+  });
+
+  test('network categories → net', () => {
+    for (const c of ['fetch', 'http', 'xhr']) {
+      expect(__mapCategoryToTypeForTests(c)).toBe('net');
+    }
+  });
+
+  test('navigation categories → nav', () => {
+    for (const c of ['nav', 'navigation', 'route']) {
+      expect(__mapCategoryToTypeForTests(c)).toBe('nav');
+    }
+  });
+
+  test('log-shaped categories → log', () => {
+    for (const c of ['console', 'log', 'sentry']) {
+      expect(__mapCategoryToTypeForTests(c)).toBe('log');
+    }
+  });
+
+  test('unknown category → custom', () => {
+    expect(__mapCategoryToTypeForTests('whatever')).toBe('custom');
+  });
+
+  test('undefined → undefined (pass-through to native default)', () => {
+    expect(__mapCategoryToTypeForTests(undefined)).toBeUndefined();
+  });
+});
+
+describe('mapLevel', () => {
+  test("Sentry's 'critical' maps to Sentori's 'fatal'", () => {
+    expect(__mapLevelForTests('critical')).toBe('fatal');
+  });
+
+  test("Sentry's 'log' maps to Sentori's 'info' (no separate Log level)", () => {
+    expect(__mapLevelForTests('log')).toBe('info');
+  });
+
+  test('5-level syslog names pass through unchanged', () => {
+    expect(__mapLevelForTests('fatal')).toBe('fatal');
+    expect(__mapLevelForTests('error')).toBe('error');
+    expect(__mapLevelForTests('warning')).toBe('warning');
+    expect(__mapLevelForTests('info')).toBe('info');
+    expect(__mapLevelForTests('debug')).toBe('debug');
+  });
+
+  test('undefined → undefined', () => {
+    expect(__mapLevelForTests(undefined)).toBeUndefined();
+  });
+});
+
+describe('Severity export', () => {
+  test('Critical collapses onto fatal', () => {
+    expect(Severity.Critical).toBe('fatal');
+  });
+  test('Log collapses onto info', () => {
+    expect(Severity.Log).toBe('info');
+  });
+  test('standard levels are themselves', () => {
+    expect(Severity.Fatal).toBe('fatal');
+    expect(Severity.Error).toBe('error');
+    expect(Severity.Warning).toBe('warning');
+    expect(Severity.Info).toBe('info');
+    expect(Severity.Debug).toBe('debug');
+  });
+});

package/src/__tests__/push.test.ts

@@ -0,0 +1,178 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
+
+// Mock the native bridge layer only — leaves expo-modules-core / react-native
+// pristine so other test files in the same bun process aren't affected.
+
+type DrainResult = {
+  token?: string
+  error?: string
+  notifications: Array<Record<string, unknown>>
+  taps: Array<Record<string, unknown>>
+}
+
+let _drainQueue: DrainResult[] = []
+let _permissionAnswer: null | string = null
+let _registerInvocations = 0
+let _unregisterInvocations = 0
+
+mock.module('../native', () => ({
+  pushGetStatus: async () => _permissionAnswer,
+  pushRequestPermission: async () => _permissionAnswer ?? 'notDetermined',
+  pushRegister: () => {
+    _registerInvocations++
+  },
+  pushUnregister: () => {
+    _unregisterInvocations++
+  },
+  pushDrainState: async () => {
+    if (_drainQueue.length === 0) {
+      return { notifications: [], taps: [] }
+    }
+    return _drainQueue.shift()!
+  },
+}))
+
+// Mock the config getter — push reads ingest URL + bearer from here.
+// Stub ALL public exports so other test files that import named
+// exports from '../config' don't get a "Export named X not found"
+// error from the partial mock (bun mock.module replaces the whole
+// module surface, not just the named exports listed).
+let _mockConfig: { ingestUrl: string; token: string } | null = null
+mock.module('../config', () => ({
+  getConfig: () => _mockConfig,
+  isInitialized: () => _mockConfig !== null,
+  setConfig: (c: typeof _mockConfig) => {
+    _mockConfig = c
+  },
+  __resetForTests: () => {
+    _mockConfig = null
+  },
+}))
+
+import { register, unregister, getCachedIpt, __setPlatformForTests } from '../push'
+
+type FetchCall = { url: string; method: string; body?: string }
+let _fetchCalls: FetchCall[] = []
+let _fetchResponse: { status: number; body: unknown } = {
+  status: 200,
+  body: { id: 'ipt_deadbeef' },
+}
+
+const originalFetch = globalThis.fetch
+beforeEach(() => {
+  _fetchCalls = []
+  _mockConfig = { ingestUrl: 'https://ingest.test', token: 'st_test' }
+  _drainQueue = []
+  _permissionAnswer = null
+  _registerInvocations = 0
+  _unregisterInvocations = 0
+  _fetchResponse = { status: 200, body: { id: 'ipt_deadbeef' } }
+  globalThis.fetch = (async (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    _fetchCalls.push({
+      url: typeof input === 'string' ? input : input.toString(),
+      method: init?.method ?? 'GET',
+      body: typeof init?.body === 'string' ? init.body : undefined,
+    })
+    return new Response(JSON.stringify(_fetchResponse.body), {
+      status: _fetchResponse.status,
+    })
+  }) as typeof fetch
+})
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+})
+
+describe('push.register', () => {
+  it('rejects cleanly when permission is denied', async () => {
+    _permissionAnswer = 'denied'
+    await expect(register()).rejects.toThrow(/permission/i)
+    expect(_fetchCalls).toHaveLength(0)
+  })
+
+  it('rejects when the native token times out', async () => {
+    _permissionAnswer = 'granted'
+    await expect(register({ tokenTimeoutMs: 50 })).rejects.toThrow(/not received/i)
+    expect(_fetchCalls).toHaveLength(0)
+  })
+
+  it('POSTs to /v1/push/tokens with the APNs hex token and resolves to ipt', async () => {
+    _permissionAnswer = 'granted'
+    _drainQueue = [
+      { notifications: [], taps: [] },
+      { token: '0123abcdef', notifications: [], taps: [] },
+    ]
+    const result = await register({ linkHash: 'h1' })
+    expect(result.ipt).toBe('ipt_deadbeef')
+    expect(getCachedIpt()).toBe('ipt_deadbeef')
+    expect(_fetchCalls).toHaveLength(1)
+    expect(_fetchCalls[0]?.url).toContain('/v1/push/tokens')
+    expect(_fetchCalls[0]?.method).toBe('POST')
+    const body = JSON.parse(_fetchCalls[0]?.body ?? '{}')
+    expect(body.provider).toBe('apns')
+    expect(body.nativeToken).toBe('0123abcdef')
+    expect(body.linkHash).toBe('h1')
+    expect(_registerInvocations).toBe(1)
+  })
+
+  it('surfaces server failures', async () => {
+    _permissionAnswer = 'granted'
+    _drainQueue = [{ token: '00ff', notifications: [], taps: [] }]
+    _fetchResponse = { status: 503, body: { error: 'dbNotConfigured' } }
+    await expect(register()).rejects.toThrow(/503/)
+  })
+
+  it('fires onMessage for buffered notifications surfaced during waitForToken', async () => {
+    _permissionAnswer = 'granted'
+    _drainQueue = [
+      {
+        notifications: [
+          { id: 'n1', title: 'Hi', body: 'hello', userInfo: { x: 1 } },
+        ],
+        taps: [],
+      },
+      { token: 'abcd', notifications: [], taps: [] },
+    ]
+    const seen: Array<{ title?: string; body?: string }> = []
+    await register({ onMessage: (m) => seen.push(m) })
+    expect(seen).toHaveLength(1)
+    expect(seen[0]?.title).toBe('Hi')
+    expect(seen[0]?.body).toBe('hello')
+  })
+})
+
+describe('push.register — Android (FCM) branch', () => {
+  beforeEach(() => __setPlatformForTests('android'))
+  afterEach(() => __setPlatformForTests(null))
+
+  it('POSTs with provider:"fcm" and omits env on Android', async () => {
+    _permissionAnswer = 'granted'
+    _drainQueue = [{ token: 'fcm-reg-token', notifications: [], taps: [] }]
+    await register()
+    expect(_fetchCalls).toHaveLength(1)
+    const body = JSON.parse(_fetchCalls[0]?.body ?? '{}') as Record<string, unknown>
+    expect(body.provider).toBe('fcm')
+    expect(body.nativeToken).toBe('fcm-reg-token')
+    expect('env' in body).toBe(false)
+  })
+})
+
+describe('push.unregister', () => {
+  it('DELETEs the cached ipt and clears the local state', async () => {
+    _permissionAnswer = 'granted'
+    _drainQueue = [{ token: 'feedface', notifications: [], taps: [] }]
+    await register()
+    expect(getCachedIpt()).toBe('ipt_deadbeef')
+    _fetchCalls = []
+
+    await unregister()
+    expect(_fetchCalls).toHaveLength(1)
+    expect(_fetchCalls[0]?.url).toContain('/v1/push/tokens/ipt_deadbeef')
+    expect(_fetchCalls[0]?.method).toBe('DELETE')
+    expect(getCachedIpt()).toBeNull()
+    expect(_unregisterInvocations).toBeGreaterThan(0)
+  })
+})

package/src/capture.ts

@@ -1,4 +1,5 @@
 import {
+  type BeforeSendHook,
   type CaptureMessageOptions,
   hashIdentities,
   type LinkBy,
@@ -296,11 +297,49 @@ export const captureError = (error: Error, extras?: CaptureExtras): void => {
         'kinds=', (event.attachments ?? []).map((a) => a.kind).join(',') || '(none)',
         'breadcrumbsAtEnqueue=', __peekBreadcrumbCount(),
       );
-    enqueue(event);
+    // v2.3 — host beforeSend hook. Sync; drops on null, falls back
+    // to unmutated event on throw or non-event return.
+    const finalEvent = applyBeforeSend(event, config.beforeSend);
+    if (finalEvent === null) return;
+    enqueue(finalEvent);
   };
   void pipeline();
 };
 
+/**
+ * v2.3 — invoke the host's `beforeSend` hook (if any) under the
+ * NEVER rule. Returns the (possibly mutated) event, or null to
+ * drop. A throw / non-event return is treated as a no-op
+ * (one-shot warn + send unmodified) so a buggy host hook can't
+ * stall captures.
+ */
+let _beforeSendThrewWarned = false;
+function applyBeforeSend(event: Event, hook: BeforeSendHook | undefined): Event | null {
+  if (!hook) return event;
+  try {
+    const result = hook(event);
+    if (result === null) {
+      logger.debug('capture', 'beforeSend dropped event', 'eventId=', event.id);
+      return null;
+    }
+    if (typeof result !== 'object' || !result || typeof (result as Event).id !== 'string') {
+      // Host returned a non-event shape; fall back.
+      if (!_beforeSendThrewWarned) {
+        _beforeSendThrewWarned = true;
+        logger.warn('capture', 'beforeSend returned non-event shape; falling back to unmodified event');
+      }
+      return event;
+    }
+    return result;
+  } catch (e) {
+    if (!_beforeSendThrewWarned) {
+      _beforeSendThrewWarned = true;
+      logger.warn('capture', 'beforeSend threw; falling back to unmodified event', e);
+    }
+    return event;
+  }
+}
+
 /** v0.9.6 #2 — upload the wireframe replay ring as a `replay`
  *  attachment. Plain NDJSON (one snapshot per line) — server may
  *  gzip on storage; the network upload is base64.
@@ -452,7 +491,9 @@ export const captureMessage = safeFn(
       breadcrumbs: crumbs,
     };
 
-    enqueue(event);
+    const finalEvent = applyBeforeSend(event, config.beforeSend);
+    if (finalEvent === null) return;
+    enqueue(finalEvent);
   },
 );
 
@@ -462,6 +503,11 @@ export const captureMessage = safeFn(
  *  same code path captureException runs in production. */
 export const __captureAndAttachReplayForTests = captureAndAttachReplay;
 
+/** v2.3 — test hook for the beforeSend dispatcher. The dispatcher
+ *  is internal so the unit test reaches it directly without
+ *  needing to stub the whole transport pipeline. */
+export const __applyBeforeSendForTests = applyBeforeSend;
+
 /** Phase 42 sub-D.08: per-session screenshot quota gate. */
 function allowScreenshot(): boolean {
   const budget = screenshotBudget();

package/src/compat/sentry.ts

@@ -67,6 +67,10 @@ type SentryInitOpts = {
   [other: string]: unknown
 }
 
+/** Exported for tests only — direct callers should use `Sentry.init`,
+ *  which threads the parsed DSN through the rest of the init machinery. */
+export const __parseDsnForTests = parseDsn
+
 function parseDsn(dsn: string): { token: string; ingestUrl: string } {
   // Sentry DSN shape: `https://<key>@<host>[:port][/<projectId>]`
   // Sentori cares about `<key>` (must be `st_pk_…`) and `<host>`.
@@ -343,6 +347,10 @@ type SentryBreadcrumb = {
 
 type SentoriBreadcrumbType = 'custom' | 'log' | 'nav' | 'net' | 'user'
 
+/** Exported for tests only. */
+export const __mapCategoryToTypeForTests = mapCategoryToType
+export const __mapLevelForTests = mapLevel
+
 function mapCategoryToType(category: string | undefined): SentoriBreadcrumbType | undefined {
   if (!category) return undefined
   if (['auth', 'click', 'gesture', 'input', 'touch', 'ui'].includes(category)) return 'user'

package/src/config.ts

@@ -1,21 +1,12 @@
-import type { LogLevel } from '@goliapkg/sentori-core';
+import type { BeforeSendHook, LogLevel, ReadyInfo } from '@goliapkg/sentori-core';
 
 /**
- * Optional structured signal handed to `onReady` after init
- * completes. Host wires the callback if they want to know the SDK
- * is live (alternative to scanning console).
+ * v2.3 — `ReadyInfo` is shared across SDKs via `@goliapkg/sentori-core`
+ * so a host that switches from web to RN reads the same shape. The RN
+ * SDK always populates `native` + `coldStartMs`; the core type marks
+ * both optional for the web SDK's benefit (web has no native module).
  */
-export type ReadyInfo = {
-  /** npm version string of @goliapkg/sentori-react-native */
-  sdkVersion: string;
-  /** Milliseconds between RN cold-start signal and SDK init
-   *  completion. May be undefined if native module wasn't bound. */
-  coldStartMs?: number;
-  /** Native module status. `bound: false` means screenshot /
-   *  wireframe / native crash capture won't fire — useful for
-   *  host to know if e.g. they forgot to autolink. */
-  native: { bound: boolean; methods: string[] };
-};
+export type { ReadyInfo };
 
 export type Config = {
   token: string;
@@ -56,6 +47,12 @@ export type Config = {
    *  the native-module bind status + cold-start timing. Host
    *  wraps any host-side logging here. */
   onReady?: (info: ReadyInfo) => void;
+  /** v2.3 — host-side mutate-or-drop hook called once per event
+   *  just before transport enqueue. Return the event to send it,
+   *  `null` to drop. Sync only. If the hook throws or returns a
+   *  non-event, SDK falls back to the un-mutated event and emits
+   *  one one-shot warn. */
+  beforeSend?: BeforeSendHook;
 };
 
 let _config: Config | null = null;