@better-auth/expo 1.7.0-rc.2 → 1.7.0-rc.4

package/dist/client.d.ts

@@ -1,6 +1,7 @@
-import { parseSetCookieHeader } from "better-auth/cookies";
+import { parseSetCookieHeader } from "better-auth/cookies/utils";
 import { FocusManager, OnlineManager } from "better-auth/client";
 import { ClientFetchOption, ClientStore } from "@better-auth/core";
+import * as SecureStore from "expo-secure-store";
 //#region src/focus-manager.d.ts
 declare function setupExpoFocusManager(): FocusManager;
 //#endregion
@@ -8,12 +9,13 @@ declare function setupExpoFocusManager(): FocusManager;
 declare function setupExpoOnlineManager(): OnlineManager;
 //#endregion
 //#region src/client.d.ts
+/**
+ * Storage used by the Expo client for cookies and cached session data.
+ */
+type ExpoClientStorage = Pick<typeof SecureStore, "setItem" | "setItemAsync" | "getItem" | "getItemAsync">;
 interface ExpoClientOptions {
   scheme?: string | undefined;
-  storage: {
-    setItem: (key: string, value: string) => any;
-    getItem: (key: string) => string | null;
-  };
+  storage: ExpoClientStorage;
   /**
    * Prefix for local storage keys (e.g., "my-app_cookie", "my-app_session_data")
    * @default "better-auth"
@@ -52,7 +54,7 @@ interface ExpoClientOptions {
   webBrowserOptions?: import("expo-web-browser").AuthSessionOpenOptions;
 }
 declare function getSetCookie(header: string, prevCookie?: string | undefined): string;
-declare function getCookie(cookie: string): string;
+declare function getCookie(cookie: string | null): string;
 /**
  * Check if the Set-Cookie header contains better-auth cookies.
  * This prevents infinite refetching when non-better-auth cookies (like third-party cookies) change.
@@ -79,16 +81,14 @@ declare function hasBetterAuthCookies(setCookieHeader: string, cookiePrefix: str
  * @returns normalized cookie name
  */
 declare function normalizeCookieName(name: string): string;
-declare function storageAdapter(storage: {
-  getItem: (name: string) => string | null;
-  setItem: (name: string, value: string) => unknown;
-}): {
+declare function storageAdapter(storage: ExpoClientStorage): {
   /**
    * Reads a value, reassembling it if it was split across chunk keys. A value
    * that fit is returned as-is (values written before chunking still read
    * back); a missing chunk returns `null` so a torn write fails closed.
    */
   getItem: (name: string) => string | null;
+  getItemAsync: (name: string) => Promise<string | null>;
   /**
    * Stores `value`, splitting it across chunk keys when it exceeds the
    * per-write limit. The base key is cleared before the chunks are rewritten
@@ -97,28 +97,27 @@ declare function storageAdapter(storage: {
    * Failures are logged, not thrown: persistence is best-effort and must not
    * break the request.
    */
-  setItem: (name: string, value: string) => Promise<void>;
+  setItem: (name: string, value: string) => void;
+  setItemAsync: (name: string, value: string) => Promise<void>;
 };
 declare const expoClient: (opts: ExpoClientOptions) => {
   id: "expo";
   version: string;
-  getActions(_: import("@better-fetch/fetch").BetterFetch, $store: ClientStore): {
+  getActions(_fetch: unknown, $store: ClientStore): {
     /**
      * Get the stored cookie.
      *
-     * You can use this to get the cookie stored in the device and use it in your fetch
-     * requests.
-     *
      * @example
      * ```ts
-     * const cookie = client.getCookie();
+     * const cookie = await client.getCookie();
      * fetch("https://api.example.com", {
      * 	headers: {
      * 		cookie,
      * 	},
      * });
+     * ```
      */
-    getCookie: () => string;
+    getCookie: () => Promise<string>;
   };
   fetchPlugins: {
     id: string;
@@ -187,4 +186,4 @@ declare const expoClient: (opts: ExpoClientOptions) => {
   }[];
 };
 //#endregion
-export { expoClient, getCookie, getSetCookie, hasBetterAuthCookies, normalizeCookieName, parseSetCookieHeader, setupExpoFocusManager, setupExpoOnlineManager, storageAdapter };
+export { ExpoClientStorage, expoClient, getCookie, getSetCookie, hasBetterAuthCookies, normalizeCookieName, parseSetCookieHeader, setupExpoFocusManager, setupExpoOnlineManager, storageAdapter };

package/dist/client.js

@@ -1,6 +1,6 @@
-import { t as PACKAGE_VERSION } from "./version-m-Zfjx6T.js";
+import { t as PACKAGE_VERSION } from "./version-Do0kTnv7.js";
 import { safeJSONParse } from "@better-auth/core/utils/json";
-import { SECURE_COOKIE_PREFIX, parseSetCookieHeader, parseSetCookieHeader as parseSetCookieHeader$1, stripSecureCookiePrefix } from "better-auth/cookies";
+import { SECURE_COOKIE_PREFIX, parseSetCookieHeader, parseSetCookieHeader as parseSetCookieHeader$1, stripSecureCookiePrefix } from "better-auth/cookies/utils";
 import Constants from "expo-constants";
 import * as Linking from "expo-linking";
 import { AppState, Platform } from "react-native";
@@ -81,6 +81,9 @@ if (Platform.OS !== "web") {
 	setupExpoFocusManager();
 	setupExpoOnlineManager();
 }
+function defineExpoClientPlugin(plugin) {
+	return plugin;
+}
 function getSetCookie(header, prevCookie) {
 	const parsed = parseSetCookieHeader$1(header);
 	const toSetCookie = safeJSONParse(prevCookie) ?? {};
@@ -104,10 +107,7 @@ function getSetCookie(header, prevCookie) {
 	return JSON.stringify(toSetCookie);
 }
 function getCookie(cookie) {
-	let parsed = {};
-	try {
-		parsed = JSON.parse(cookie);
-	} catch {}
+	const parsed = safeJSONParse(cookie) ?? {};
 	return Object.entries(parsed).reduce((acc, [key, value]) => {
 		if (value.expires && new Date(value.expires) < /* @__PURE__ */ new Date()) return acc;
 		return acc ? `${acc}; ${key}=${value.value}` : `${key}=${value.value}`;
@@ -210,6 +210,17 @@ const STORAGE_VALUE_LIMIT = 1800;
 * survives the native storage bridge without C-string truncation.
 */
 const CHUNK_MARKER = "
ba-chunks:";
+function getStorageWrites(key, value) {
+	if (value.length <= STORAGE_VALUE_LIMIT) return [[key, value]];
+	const count = Math.ceil(value.length / STORAGE_VALUE_LIMIT);
+	const writes = [[key, ""]];
+	for (let i = 0; i < count; i++) {
+		const start = i * STORAGE_VALUE_LIMIT;
+		writes.push([`${key}.${i}`, value.slice(start, start + STORAGE_VALUE_LIMIT)]);
+	}
+	writes.push([key, `${CHUNK_MARKER}${count}`]);
+	return writes;
+}
 function storageAdapter(storage) {
 	return {
 		/**
@@ -231,6 +242,20 @@ function storageAdapter(storage) {
 			}
 			return value;
 		},
+		getItemAsync: async (name) => {
+			const key = normalizeCookieName(name);
+			const stored = await storage.getItemAsync(key);
+			if (stored == null || !stored.startsWith(CHUNK_MARKER)) return stored;
+			const count = Number(stored.slice(11));
+			if (!Number.isInteger(count) || count < 1) return null;
+			let value = "";
+			for (let i = 0; i < count; i++) {
+				const chunk = await storage.getItemAsync(`${key}.${i}`);
+				if (chunk == null) return null;
+				value += chunk;
+			}
+			return value;
+		},
 		/**
 		* Stores `value`, splitting it across chunk keys when it exceeds the
 		* per-write limit. The base key is cleared before the chunks are rewritten
@@ -239,20 +264,18 @@ function storageAdapter(storage) {
 		* Failures are logged, not thrown: persistence is best-effort and must not
 		* break the request.
 		*/
-		setItem: async (name, value) => {
+		setItem: (name, value) => {
 			const key = normalizeCookieName(name);
 			try {
-				if (value.length <= STORAGE_VALUE_LIMIT) {
-					await storage.setItem(key, value);
-					return;
-				}
-				await storage.setItem(key, "");
-				const count = Math.ceil(value.length / STORAGE_VALUE_LIMIT);
-				for (let i = 0; i < count; i++) {
-					const start = i * STORAGE_VALUE_LIMIT;
-					await storage.setItem(`${key}.${i}`, value.slice(start, start + STORAGE_VALUE_LIMIT));
-				}
-				await storage.setItem(key, `${CHUNK_MARKER}${count}`);
+				for (const [writeKey, writeValue] of getStorageWrites(key, value)) storage.setItem(writeKey, writeValue);
+			} catch (error) {
+				console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
+			}
+		},
+		setItemAsync: async (name, value) => {
+			const key = normalizeCookieName(name);
+			try {
+				for (const [writeKey, writeValue] of getStorageWrites(key, value)) await storage.setItemAsync(writeKey, writeValue);
 			} catch (error) {
 				console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
 			}
@@ -264,57 +287,67 @@ const expoClient = (opts) => {
 	const storagePrefix = opts?.storagePrefix || "better-auth";
 	const cookieName = `${storagePrefix}_cookie`;
 	const localCacheName = `${storagePrefix}_session_data`;
-	const storage = storageAdapter(opts?.storage);
+	const storage = storageAdapter(opts.storage);
 	const isWeb = Platform.OS === "web";
 	const cookiePrefix = opts?.cookiePrefix || "better-auth";
+	let sessionCacheHydration;
+	const restoreSessionCache = async () => {
+		if (isWeb || opts?.disableCache) return;
+		const sessionAtom = store?.atoms.session;
+		if (!sessionAtom) return;
+		const initialSessionState = sessionAtom.get();
+		if (initialSessionState.data !== null) return;
+		const raw = await storage.getItemAsync(localCacheName);
+		const cached = raw ? safeJSONParse(raw) : null;
+		const expiresAt = cached?.session?.expiresAt;
+		const expiresAtMs = expiresAt ? new Date(expiresAt).getTime() : NaN;
+		if (!!cached?.user?.id && !!cached.session?.id && expiresAtMs > Date.now() && sessionAtom.get() === initialSessionState) sessionAtom.set({
+			...initialSessionState,
+			data: cached,
+			error: null
+		});
+	};
+	const hydrateSessionCache = () => {
+		if (!sessionCacheHydration) sessionCacheHydration = restoreSessionCache().catch((error) => {
+			sessionCacheHydration = void 0;
+			throw error;
+		});
+		return sessionCacheHydration;
+	};
 	const clearSessionCache = async () => {
-		await storage.setItem(cookieName, "{}");
+		await storage.setItemAsync(cookieName, "{}");
 		store?.atoms.session?.set({
 			...store.atoms.session.get(),
 			data: null,
 			error: null,
 			isPending: false
 		});
-		await storage.setItem(localCacheName, "{}");
+		await storage.setItemAsync(localCacheName, "{}");
 	};
 	const rawScheme = opts?.scheme || Constants.expoConfig?.scheme || Constants.platform?.scheme;
 	const scheme = Array.isArray(rawScheme) ? rawScheme[0] : rawScheme;
 	if (!scheme && !isWeb) throw new Error("Scheme not found in app.json. Please provide a scheme in the options.");
-	return {
+	return defineExpoClientPlugin({
 		id: "expo",
 		version: PACKAGE_VERSION,
-		getActions(_, $store) {
+		getActions(_fetch, $store) {
 			store = $store;
-			const sessionAtom = $store.atoms.session;
-			if (!isWeb && !opts?.disableCache && sessionAtom) {
-				const raw = storage.getItem(localCacheName);
-				const cached = raw ? safeJSONParse(raw) : null;
-				const exp = cached?.session?.expiresAt;
-				const expMs = exp ? new Date(exp).getTime() : NaN;
-				if (!!cached?.user?.id && !!cached.session?.id && expMs > Date.now()) sessionAtom.set({
-					...sessionAtom.get(),
-					data: cached,
-					error: null
-				});
-			}
 			return { 
 			/**
 			* Get the stored cookie.
 			*
-			* You can use this to get the cookie stored in the device and use it in your fetch
-			* requests.
-			*
 			* @example
 			* ```ts
-			* const cookie = client.getCookie();
+			* const cookie = await client.getCookie();
 			* fetch("https://api.example.com", {
 			* 	headers: {
 			* 		cookie,
 			* 	},
 			* });
+			* ```
 			*/
-getCookie: () => {
-				return getCookie(storage.getItem(cookieName) || "{}");
+getCookie: async () => {
+				return getCookie(await storage.getItemAsync(cookieName));
 			} };
 		},
 		fetchPlugins: [{
@@ -322,23 +355,26 @@ getCookie: () => {
 			name: "Expo",
 			hooks: { async onSuccess(context) {
 				if (isWeb) return;
+				const { pathname } = new URL(context.request.url);
 				const setCookie = context.response.headers.get("set-cookie");
 				if (setCookie) {
 					if (hasBetterAuthCookies(setCookie, cookiePrefix)) {
-						const prevCookie = storage.getItem(cookieName);
+						const prevCookie = await storage.getItemAsync(cookieName);
 						const toSetCookie = getSetCookie(setCookie || "", prevCookie ?? void 0);
 						if (hasSessionCookieChanged(prevCookie, toSetCookie)) {
-							await storage.setItem(cookieName, toSetCookie);
+							await storage.setItemAsync(cookieName, toSetCookie);
 							store?.notify("$sessionSignal");
-						} else await storage.setItem(cookieName, toSetCookie);
+						} else await storage.setItemAsync(cookieName, toSetCookie);
 					}
 				}
-				if (context.request.url.toString().includes("/get-session") && !opts?.disableCache) {
+				if (pathname.endsWith("/get-session") && !opts?.disableCache) {
 					const data = context.data;
-					await storage.setItem(localCacheName, JSON.stringify(data));
+					await storage.setItemAsync(localCacheName, JSON.stringify(data));
 				}
-				if (context.request.url.toString().includes("/sign-out")) await clearSessionCache();
-				if (context.data?.redirect && (context.request.url.toString().includes("/sign-in") || context.request.url.toString().includes("/link-social")) && !context.request?.body.includes("idToken")) {
+				if (pathname.endsWith("/sign-out")) await clearSessionCache();
+				const isSignInRequest = pathname.endsWith("/sign-in") || pathname.includes("/sign-in/");
+				const isLinkSocialRequest = pathname.endsWith("/link-social");
+				if (context.data?.redirect && (isSignInRequest || isLinkSocialRequest) && !context.request?.body.includes("idToken")) {
 					const to = JSON.parse(context.request.body)?.callbackURL;
 					const signInURL = context.data?.url;
 					let Browser = void 0;
@@ -354,7 +390,7 @@ getCookie: () => {
 					if (Platform.OS === "android") try {
 						Browser.dismissAuthSession();
 					} catch {}
-					const oauthStateValue = getOAuthStateValue(storage.getItem(cookieName), cookiePrefix);
+					const oauthStateValue = getOAuthStateValue(await storage.getItemAsync(cookieName), cookiePrefix);
 					const params = new URLSearchParams({ authorizationURL: signInURL });
 					if (oauthStateValue) params.append("oauthState", oauthStateValue);
 					const proxyURL = `${context.request.baseURL}/expo-authorization-proxy?${params.toString()}`;
@@ -362,8 +398,8 @@ getCookie: () => {
 					if (result.type !== "success") return;
 					const cookie = new URL(result.url).searchParams.get("cookie");
 					if (!cookie) return;
-					const toSetCookie = getSetCookie(cookie, storage.getItem(cookieName) ?? void 0);
-					await storage.setItem(cookieName, toSetCookie);
+					const toSetCookie = getSetCookie(cookie, await storage.getItemAsync(cookieName) ?? void 0);
+					await storage.setItemAsync(cookieName, toSetCookie);
 					store?.notify("$sessionSignal");
 				}
 			} },
@@ -372,17 +408,19 @@ getCookie: () => {
 					url,
 					options
 				};
+				const { pathname } = new URL(url, options?.baseURL);
+				if (pathname.endsWith("/get-session")) await hydrateSessionCache();
 				options = options || {};
 				options.credentials = "omit";
 				if (options.body?.idToken !== void 0) {
-					const cookie = url.includes("/link-social") ? getCookie(storage.getItem(cookieName) || "{}") : "";
+					const cookie = getCookie(pathname.endsWith("/link-social") ? await storage.getItemAsync(cookieName) : null);
 					options.headers = {
 						...options.headers,
 						...cookie ? { cookie } : {},
 						"x-skip-oauth-proxy": "true"
 					};
 				} else {
-					const cookie = getCookie(storage.getItem(cookieName) || "{}");
+					const cookie = getCookie(await storage.getItemAsync(cookieName));
 					options.headers = {
 						...options.headers,
 						...cookie ? { cookie } : {},
@@ -407,7 +445,7 @@ getCookie: () => {
 							options.body.errorCallbackURL = url;
 						}
 					}
-					if (url.includes("/sign-out")) await clearSessionCache();
+					if (pathname.endsWith("/sign-out")) await clearSessionCache();
 				}
 				return {
 					url,
@@ -415,7 +453,7 @@ getCookie: () => {
 				};
 			}
 		}]
-	};
+	});
 };
 //#endregion
 export { expoClient, getCookie, getSetCookie, hasBetterAuthCookies, normalizeCookieName, parseSetCookieHeader, setupExpoFocusManager, setupExpoOnlineManager, storageAdapter };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-m-Zfjx6T.js";
+import { t as PACKAGE_VERSION } from "./version-Do0kTnv7.js";
 import { createAuthMiddleware } from "@better-auth/core/api";
 import { HIDE_METADATA } from "better-auth";
 import { APIError, createAuthEndpoint } from "better-auth/api";

package/dist/plugins/index.js

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "../version-m-Zfjx6T.js";
+import { t as PACKAGE_VERSION } from "../version-Do0kTnv7.js";
 //#region src/plugins/last-login-method.ts
 const paths = [
 	"/callback/",

package/dist/{version-m-Zfjx6T.js → version-Do0kTnv7.js}

@@ -1,5 +1,5 @@
 //#endregion
 //#region src/version.ts
-const PACKAGE_VERSION = "1.7.0-rc.2";
+const PACKAGE_VERSION = "1.7.0-rc.4";
 //#endregion
 export { PACKAGE_VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/expo",
-  "version": "1.7.0-rc.2",
+  "version": "1.7.0-rc.4",
   "description": "Better Auth integration for Expo and React Native applications.",
   "type": "module",
   "license": "MIT",
@@ -67,19 +67,21 @@
     "expo-constants": "~56.0.18",
     "expo-linking": "~56.0.14",
     "expo-network": "~56.0.5",
+    "expo-secure-store": "~56.0.4",
     "expo-web-browser": "~56.0.5",
     "react-native": "~0.86.0",
     "tsdown": "0.22.7",
-    "@better-auth/core": "1.7.0-rc.2",
-    "better-auth": "1.7.0-rc.2"
+    "@better-auth/core": "1.7.0-rc.4",
+    "better-auth": "1.7.0-rc.4"
   },
   "peerDependencies": {
     "expo-constants": ">=17.0.0",
     "expo-linking": ">=7.0.0",
     "expo-network": ">=8.0.7",
+    "expo-secure-store": ">=12.5.0",
     "expo-web-browser": ">=14.0.0",
-    "@better-auth/core": "^1.7.0-rc.2",
-    "better-auth": "^1.7.0-rc.2"
+    "@better-auth/core": "^1.7.0-rc.4",
+    "better-auth": "^1.7.0-rc.4"
   },
   "peerDependenciesMeta": {
     "expo-constants": {
@@ -91,6 +93,9 @@
     "expo-network": {
       "optional": true
     },
+    "expo-secure-store": {
+      "optional": true
+    },
     "expo-web-browser": {
       "optional": true
     }