@sendoracloud/sdk-react-native 1.8.1 → 1.9.0

package/dist/index.cjs

@@ -43,6 +43,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_react_native_get_random_values = require("react-native-get-random-values");
+var import_react_native4 = require("react-native");
 
 // src/storage.ts
 var PREFIX = "sendora_";
@@ -222,7 +223,7 @@ async function request(opts, method, path, body, extraHeaders, reqOpts) {
 // package.json
 var package_default = {
   name: "@sendoracloud/sdk-react-native",
-  version: "1.8.1",
+  version: "1.9.0",
   description: "Sendora Cloud React Native + Expo SDK \u2014 analytics, identity, push-token registration, auth, deep links (Branch / Firebase Dynamic Links parity). Auth + analytics + deep links work in Expo Go; push token registration requires a Dev Client (EAS Build or `npx expo prebuild`).",
   type: "module",
   main: "./dist/index.cjs",
@@ -465,38 +466,44 @@ var Auth = class {
     }
   }
   /**
-   * Returns an access token or null. Cold-launch hardening (Wave 62):
+   * Returns a VALID (non-expired) access token, or null.
    *
-   *  1. Non-expired cached → return it. (Fast path.)
-   *  2. Expired AND refresh inflight → return stale cached anyway.
-   *     Backend grace window (60s — see auth-service refresh-rotation
-   *     middleware) accepts slightly-stale access tokens, so the
-   *     caller's downstream RPC will succeed against grace while
-   *     the in-flight refresh resolves out of band. Distinct from
-   *     pre-Wave-62 behaviour where 5 concurrent callers all shared
-   *     the same in-flight promise — when that promise hung (iOS
-   *     NSURLSession cold-launch contention) every caller hung too.
-   *  3. Expired + no inflight + refresh available + not in cooldown →
-   *     fire refresh, await it.
-   *  4. Expired + in cooldown → return stale cached. Caller's RPC
-   *     either succeeds against grace or fails fast on 401, which is
-   *     a better UX than blocking the whole bridge waiting on a
-   *     network that we already know is stalled.
+   * Hard contract (matches sdk-ios / sdk-android, and the industry
+   * token-client pattern — Supabase `_callRefreshToken`, Auth0
+   * `getTokenSilently`, Firebase `getIdToken`): this method NEVER
+   * returns a token past its `exp`. Callers attach the result as a
+   * Bearer to arbitrary resource servers — including third-party
+   * backends (PostgREST/Supabase) that have NO knowledge of Sendora's
+   * own refresh grace window — so a token must be either fresh or
+   * absent. A token expired by hours is useless and yields a 401.
    *
-   * Returns null only when there's NO usable token at all (no cached
-   * + no refresh available).
+   * Resolution order:
+   *  1. Cached token with comfortable life left (>= REFRESH_SAFETY_MS
+   *     skew before exp) → return it. Fast path, no I/O.
+   *  2. No cached token AND no refresh token in storage → genuinely
+   *     signed out → null.
+   *  3. Expired/near-expiry but a refresh chain exists:
+   *     a. A refresh is already inflight → AWAIT it and return the
+   *        fresh token. Concurrent callers coalesce onto the single
+   *        in-flight `/token/refresh` (single-flight) — nobody is
+   *        handed a stale token. The inflight fetch is
+   *        AbortController-bounded (http.ts caps `/auth-service/*` at
+   *        10s), so awaiting can NEVER hang the JS bridge. That
+   *        bounded-fetch guarantee — NOT the old stale-token return —
+   *        is what actually fixed the Wave-62 cold-launch hang.
+   *     b. A recent refresh failed and we're in backoff cooldown →
+   *        null. Honest "no usable token right now" rather than a
+   *        provably-expired one; the AppState foreground hook clears
+   *        the cooldown for an immediate retry on resume.
+   *     c. Otherwise → fire the refresh and await it.
    */
   async getAccessToken() {
-    if (!this.accessToken) return null;
-    if (this.accessExpiresAt && Date.now() < this.accessExpiresAt - REFRESH_SAFETY_MS) {
-      return this.accessToken;
-    }
-    if (this.refreshInflight) {
-      return this.accessToken;
-    }
-    if (Date.now() < this.refreshCooldownUntil) {
+    if (this.accessToken && this.accessExpiresAt && Date.now() < this.accessExpiresAt - REFRESH_SAFETY_MS) {
       return this.accessToken;
     }
+    if (!this.hooks.storage.get(REFRESH_KEY)) return null;
+    if (this.refreshInflight) return this.refreshInflight;
+    if (Date.now() < this.refreshCooldownUntil) return null;
     return this.refreshAccessToken();
   }
   /** Sync read — returns whatever's cached even if expired. Prefer the async variant. */
@@ -2029,6 +2036,22 @@ function byteLength(s) {
     return s.length * 4;
   }
 }
+function buildDeviceContext(appVersion) {
+  try {
+    const os = import_react_native4.Platform?.OS;
+    if (os !== "ios" && os !== "android") return void 0;
+    const isPad = os === "ios" && import_react_native4.Platform.isPad === true;
+    return {
+      type: isPad ? "tablet" : "mobile",
+      os: os === "ios" ? "iOS" : "Android",
+      osVersion: String(import_react_native4.Platform.Version ?? ""),
+      model: "",
+      appVersion: appVersion ?? ""
+    };
+  } catch {
+    return void 0;
+  }
+}
 var SendoraSDK = class {
   constructor() {
     this.config = null;
@@ -2831,6 +2854,7 @@ var SendoraSDK = class {
   async sendEvent(kind, payload) {
     if (!this.config) return;
     if (!this.consentGranted) return;
+    const device = buildDeviceContext(this.config.appVersion);
     await post(
       { apiUrl: this.config.apiUrl, publicKey: this.config.publicKey, debug: this.debug },
       "/api/v1/events",
@@ -2845,6 +2869,7 @@ var SendoraSDK = class {
         context: {
           platform: "react-native",
           sdk: { name: "@sendoracloud/sdk-react-native", version: SDK_VERSION },
+          ...device ? { device } : {},
           ...this.config.environment ? { environment: this.config.environment } : {},
           ...kind === "identify" ? { traits: payload.traits } : {}
         }

package/dist/index.d.cts

@@ -210,26 +210,36 @@ declare class Auth {
     /** Internal — fan out to subscribers + cache the latest. */
     private fireDeviceTakeover;
     /**
-     * Returns an access token or null. Cold-launch hardening (Wave 62):
+     * Returns a VALID (non-expired) access token, or null.
      *
-     *  1. Non-expired cached → return it. (Fast path.)
-     *  2. Expired AND refresh inflight → return stale cached anyway.
-     *     Backend grace window (60s — see auth-service refresh-rotation
-     *     middleware) accepts slightly-stale access tokens, so the
-     *     caller's downstream RPC will succeed against grace while
-     *     the in-flight refresh resolves out of band. Distinct from
-     *     pre-Wave-62 behaviour where 5 concurrent callers all shared
-     *     the same in-flight promise — when that promise hung (iOS
-     *     NSURLSession cold-launch contention) every caller hung too.
-     *  3. Expired + no inflight + refresh available + not in cooldown →
-     *     fire refresh, await it.
-     *  4. Expired + in cooldown → return stale cached. Caller's RPC
-     *     either succeeds against grace or fails fast on 401, which is
-     *     a better UX than blocking the whole bridge waiting on a
-     *     network that we already know is stalled.
+     * Hard contract (matches sdk-ios / sdk-android, and the industry
+     * token-client pattern — Supabase `_callRefreshToken`, Auth0
+     * `getTokenSilently`, Firebase `getIdToken`): this method NEVER
+     * returns a token past its `exp`. Callers attach the result as a
+     * Bearer to arbitrary resource servers — including third-party
+     * backends (PostgREST/Supabase) that have NO knowledge of Sendora's
+     * own refresh grace window — so a token must be either fresh or
+     * absent. A token expired by hours is useless and yields a 401.
      *
-     * Returns null only when there's NO usable token at all (no cached
-     * + no refresh available).
+     * Resolution order:
+     *  1. Cached token with comfortable life left (>= REFRESH_SAFETY_MS
+     *     skew before exp) → return it. Fast path, no I/O.
+     *  2. No cached token AND no refresh token in storage → genuinely
+     *     signed out → null.
+     *  3. Expired/near-expiry but a refresh chain exists:
+     *     a. A refresh is already inflight → AWAIT it and return the
+     *        fresh token. Concurrent callers coalesce onto the single
+     *        in-flight `/token/refresh` (single-flight) — nobody is
+     *        handed a stale token. The inflight fetch is
+     *        AbortController-bounded (http.ts caps `/auth-service/*` at
+     *        10s), so awaiting can NEVER hang the JS bridge. That
+     *        bounded-fetch guarantee — NOT the old stale-token return —
+     *        is what actually fixed the Wave-62 cold-launch hang.
+     *     b. A recent refresh failed and we're in backoff cooldown →
+     *        null. Honest "no usable token right now" rather than a
+     *        provably-expired one; the AppState foreground hook clears
+     *        the cooldown for an immediate retry on resume.
+     *     c. Otherwise → fire the refresh and await it.
      */
     getAccessToken(): Promise<string | null>;
     /** Sync read — returns whatever's cached even if expired. Prefer the async variant. */
@@ -806,6 +816,14 @@ interface SendoraConfig {
      * Added 0.16.0.
      */
     linkDomain?: string;
+    /**
+     * Your app's version (e.g. "2.4.0"). Attached to every event's
+     * `context.device.appVersion` so the dashboard can break analytics down by
+     * release (ADR-022). Optional — RN has no zero-dep way to auto-read the
+     * host app version, so supply it (e.g. from `expo-constants` /
+     * `react-native-device-info`) if you want app-version analytics.
+     */
+    appVersion?: string;
 }
 type TraitValue = string | number | boolean | null | undefined;
 interface IdentifyTraits {

package/dist/index.d.ts

@@ -210,26 +210,36 @@ declare class Auth {
     /** Internal — fan out to subscribers + cache the latest. */
     private fireDeviceTakeover;
     /**
-     * Returns an access token or null. Cold-launch hardening (Wave 62):
+     * Returns a VALID (non-expired) access token, or null.
      *
-     *  1. Non-expired cached → return it. (Fast path.)
-     *  2. Expired AND refresh inflight → return stale cached anyway.
-     *     Backend grace window (60s — see auth-service refresh-rotation
-     *     middleware) accepts slightly-stale access tokens, so the
-     *     caller's downstream RPC will succeed against grace while
-     *     the in-flight refresh resolves out of band. Distinct from
-     *     pre-Wave-62 behaviour where 5 concurrent callers all shared
-     *     the same in-flight promise — when that promise hung (iOS
-     *     NSURLSession cold-launch contention) every caller hung too.
-     *  3. Expired + no inflight + refresh available + not in cooldown →
-     *     fire refresh, await it.
-     *  4. Expired + in cooldown → return stale cached. Caller's RPC
-     *     either succeeds against grace or fails fast on 401, which is
-     *     a better UX than blocking the whole bridge waiting on a
-     *     network that we already know is stalled.
+     * Hard contract (matches sdk-ios / sdk-android, and the industry
+     * token-client pattern — Supabase `_callRefreshToken`, Auth0
+     * `getTokenSilently`, Firebase `getIdToken`): this method NEVER
+     * returns a token past its `exp`. Callers attach the result as a
+     * Bearer to arbitrary resource servers — including third-party
+     * backends (PostgREST/Supabase) that have NO knowledge of Sendora's
+     * own refresh grace window — so a token must be either fresh or
+     * absent. A token expired by hours is useless and yields a 401.
      *
-     * Returns null only when there's NO usable token at all (no cached
-     * + no refresh available).
+     * Resolution order:
+     *  1. Cached token with comfortable life left (>= REFRESH_SAFETY_MS
+     *     skew before exp) → return it. Fast path, no I/O.
+     *  2. No cached token AND no refresh token in storage → genuinely
+     *     signed out → null.
+     *  3. Expired/near-expiry but a refresh chain exists:
+     *     a. A refresh is already inflight → AWAIT it and return the
+     *        fresh token. Concurrent callers coalesce onto the single
+     *        in-flight `/token/refresh` (single-flight) — nobody is
+     *        handed a stale token. The inflight fetch is
+     *        AbortController-bounded (http.ts caps `/auth-service/*` at
+     *        10s), so awaiting can NEVER hang the JS bridge. That
+     *        bounded-fetch guarantee — NOT the old stale-token return —
+     *        is what actually fixed the Wave-62 cold-launch hang.
+     *     b. A recent refresh failed and we're in backoff cooldown →
+     *        null. Honest "no usable token right now" rather than a
+     *        provably-expired one; the AppState foreground hook clears
+     *        the cooldown for an immediate retry on resume.
+     *     c. Otherwise → fire the refresh and await it.
      */
     getAccessToken(): Promise<string | null>;
     /** Sync read — returns whatever's cached even if expired. Prefer the async variant. */
@@ -806,6 +816,14 @@ interface SendoraConfig {
      * Added 0.16.0.
      */
     linkDomain?: string;
+    /**
+     * Your app's version (e.g. "2.4.0"). Attached to every event's
+     * `context.device.appVersion` so the dashboard can break analytics down by
+     * release (ADR-022). Optional — RN has no zero-dep way to auto-read the
+     * host app version, so supply it (e.g. from `expo-constants` /
+     * `react-native-device-info`) if you want app-version analytics.
+     */
+    appVersion?: string;
 }
 type TraitValue = string | number | boolean | null | undefined;
 interface IdentifyTraits {

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/index.ts
 import "react-native-get-random-values";
+import { Platform } from "react-native";
 
 // src/storage.ts
 var PREFIX = "sendora_";
@@ -179,7 +180,7 @@ async function request(opts, method, path, body, extraHeaders, reqOpts) {
 // package.json
 var package_default = {
   name: "@sendoracloud/sdk-react-native",
-  version: "1.8.1",
+  version: "1.9.0",
   description: "Sendora Cloud React Native + Expo SDK \u2014 analytics, identity, push-token registration, auth, deep links (Branch / Firebase Dynamic Links parity). Auth + analytics + deep links work in Expo Go; push token registration requires a Dev Client (EAS Build or `npx expo prebuild`).",
   type: "module",
   main: "./dist/index.cjs",
@@ -422,38 +423,44 @@ var Auth = class {
     }
   }
   /**
-   * Returns an access token or null. Cold-launch hardening (Wave 62):
+   * Returns a VALID (non-expired) access token, or null.
    *
-   *  1. Non-expired cached → return it. (Fast path.)
-   *  2. Expired AND refresh inflight → return stale cached anyway.
-   *     Backend grace window (60s — see auth-service refresh-rotation
-   *     middleware) accepts slightly-stale access tokens, so the
-   *     caller's downstream RPC will succeed against grace while
-   *     the in-flight refresh resolves out of band. Distinct from
-   *     pre-Wave-62 behaviour where 5 concurrent callers all shared
-   *     the same in-flight promise — when that promise hung (iOS
-   *     NSURLSession cold-launch contention) every caller hung too.
-   *  3. Expired + no inflight + refresh available + not in cooldown →
-   *     fire refresh, await it.
-   *  4. Expired + in cooldown → return stale cached. Caller's RPC
-   *     either succeeds against grace or fails fast on 401, which is
-   *     a better UX than blocking the whole bridge waiting on a
-   *     network that we already know is stalled.
+   * Hard contract (matches sdk-ios / sdk-android, and the industry
+   * token-client pattern — Supabase `_callRefreshToken`, Auth0
+   * `getTokenSilently`, Firebase `getIdToken`): this method NEVER
+   * returns a token past its `exp`. Callers attach the result as a
+   * Bearer to arbitrary resource servers — including third-party
+   * backends (PostgREST/Supabase) that have NO knowledge of Sendora's
+   * own refresh grace window — so a token must be either fresh or
+   * absent. A token expired by hours is useless and yields a 401.
    *
-   * Returns null only when there's NO usable token at all (no cached
-   * + no refresh available).
+   * Resolution order:
+   *  1. Cached token with comfortable life left (>= REFRESH_SAFETY_MS
+   *     skew before exp) → return it. Fast path, no I/O.
+   *  2. No cached token AND no refresh token in storage → genuinely
+   *     signed out → null.
+   *  3. Expired/near-expiry but a refresh chain exists:
+   *     a. A refresh is already inflight → AWAIT it and return the
+   *        fresh token. Concurrent callers coalesce onto the single
+   *        in-flight `/token/refresh` (single-flight) — nobody is
+   *        handed a stale token. The inflight fetch is
+   *        AbortController-bounded (http.ts caps `/auth-service/*` at
+   *        10s), so awaiting can NEVER hang the JS bridge. That
+   *        bounded-fetch guarantee — NOT the old stale-token return —
+   *        is what actually fixed the Wave-62 cold-launch hang.
+   *     b. A recent refresh failed and we're in backoff cooldown →
+   *        null. Honest "no usable token right now" rather than a
+   *        provably-expired one; the AppState foreground hook clears
+   *        the cooldown for an immediate retry on resume.
+   *     c. Otherwise → fire the refresh and await it.
    */
   async getAccessToken() {
-    if (!this.accessToken) return null;
-    if (this.accessExpiresAt && Date.now() < this.accessExpiresAt - REFRESH_SAFETY_MS) {
-      return this.accessToken;
-    }
-    if (this.refreshInflight) {
-      return this.accessToken;
-    }
-    if (Date.now() < this.refreshCooldownUntil) {
+    if (this.accessToken && this.accessExpiresAt && Date.now() < this.accessExpiresAt - REFRESH_SAFETY_MS) {
       return this.accessToken;
     }
+    if (!this.hooks.storage.get(REFRESH_KEY)) return null;
+    if (this.refreshInflight) return this.refreshInflight;
+    if (Date.now() < this.refreshCooldownUntil) return null;
     return this.refreshAccessToken();
   }
   /** Sync read — returns whatever's cached even if expired. Prefer the async variant. */
@@ -1991,6 +1998,22 @@ function byteLength(s) {
     return s.length * 4;
   }
 }
+function buildDeviceContext(appVersion) {
+  try {
+    const os = Platform?.OS;
+    if (os !== "ios" && os !== "android") return void 0;
+    const isPad = os === "ios" && Platform.isPad === true;
+    return {
+      type: isPad ? "tablet" : "mobile",
+      os: os === "ios" ? "iOS" : "Android",
+      osVersion: String(Platform.Version ?? ""),
+      model: "",
+      appVersion: appVersion ?? ""
+    };
+  } catch {
+    return void 0;
+  }
+}
 var SendoraSDK = class {
   constructor() {
     this.config = null;
@@ -2793,6 +2816,7 @@ var SendoraSDK = class {
   async sendEvent(kind, payload) {
     if (!this.config) return;
     if (!this.consentGranted) return;
+    const device = buildDeviceContext(this.config.appVersion);
     await post(
       { apiUrl: this.config.apiUrl, publicKey: this.config.publicKey, debug: this.debug },
       "/api/v1/events",
@@ -2807,6 +2831,7 @@ var SendoraSDK = class {
         context: {
           platform: "react-native",
           sdk: { name: "@sendoracloud/sdk-react-native", version: SDK_VERSION },
+          ...device ? { device } : {},
           ...this.config.environment ? { environment: this.config.environment } : {},
           ...kind === "identify" ? { traits: payload.traits } : {}
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendoracloud/sdk-react-native",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "Sendora Cloud React Native + Expo SDK — analytics, identity, push-token registration, auth, deep links (Branch / Firebase Dynamic Links parity). Auth + analytics + deep links work in Expo Go; push token registration requires a Dev Client (EAS Build or `npx expo prebuild`).",
   "type": "module",
   "main": "./dist/index.cjs",