@layers/amba-react-native 4.2.1 → 4.2.2

package/dist/index.cjs

@@ -249,8 +249,35 @@ function withSignal(init, signal) {
 //#region src/http-client.ts
 /** Default amba API endpoint. */
 const DEFAULT_BASE_URL = "https://api.amba.dev";
-/** Server codes for a session token the server no longer accepts. */
-const SESSION_REFUSED_CODES = new Set(["SESSION_REVOKED", "INVALID_SESSION_TOKEN"]);
+/**
+* Server codes for a session token the server no longer accepts.
+* `INVALID_SESSION` is the code the auth routes that verify the session
+* themselves (`/identifiers`, `/link`, `/unlink`) answer with.
+*/
+const SESSION_REFUSED_CODES = new Set([
+	"SESSION_REVOKED",
+	"INVALID_SESSION_TOKEN",
+	"INVALID_SESSION"
+]);
+/** True for a server error that refused the session token a call sent. */
+function isSessionRefusedError(err) {
+	return err instanceof AmbaApiError && SESSION_REFUSED_CODES.has(err.code);
+}
+const AUTH_PATH_PREFIX = "/v1/client/auth/";
+/**
+* The auth routes that read the session from the `Authorization` header and
+* mint nothing: a refused session on them recovers like it does on any
+* other authenticated call. The other auth routes stay out of the
+* recovery: `/refresh` is the recovery itself, `/logout` ends the session,
+* the sign-in, sign-up, OTP and magic-link routes take credentials (a 401
+* there is a credential error), and `/link` and `/unlink` carry the session
+* in their body, so their callers recover and rebuild the body themselves.
+*/
+const SESSION_HEADER_AUTH_PATHS = new Set([`${AUTH_PATH_PREFIX}me`, `${AUTH_PATH_PREFIX}identifiers`]);
+/** Whether a refused session on `path` goes through `onSessionRefused`. */
+function recoversRefusedSession(path) {
+	return !path.startsWith(AUTH_PATH_PREFIX) || SESSION_HEADER_AUTH_PATHS.has(path);
+}
 var AmbaHttpClient = class {
 	apiKey;
 	baseUrl;
@@ -386,7 +413,7 @@ var AmbaHttpClient = class {
 		try {
 			return parseResponse(response, text);
 		} catch (err) {
-			if (!resent && storedToken && this.onSessionRefused && !path.startsWith("/v1/client/auth/") && err instanceof AmbaApiError && SESSION_REFUSED_CODES.has(err.code) && await this.recoverSession(storedToken, storedUserId)) return this.request(method, path, body, query, void 0, true);
+			if (!resent && storedToken && this.onSessionRefused && recoversRefusedSession(path) && isSessionRefusedError(err) && await this.recoverSession(storedToken, storedUserId)) return this.request(method, path, body, query, void 0, true);
 			throw err;
 		}
 	}
@@ -2747,7 +2774,7 @@ function delay(ms) {
 //#endregion
 //#region src/index.ts
 /** SDK semver — burned in at build time. Bump alongside package.json. */
-const SDK_VERSION = "4.2.1";
+const SDK_VERSION = "4.2.2";
 /**
 * Default host that serves deployed functions. `Amba.functions.invoke(name)`
 * targets `https://<projectId>.<DEFAULT_FUNCTIONS_HOST>/<name>` unless a
@@ -3033,7 +3060,11 @@ function trackLink(state_, link) {
 }
 /**
 * After the server refused the stored session token on an authenticated
-* call (`SESSION_REVOKED`, `INVALID_SESSION_TOKEN`). True when a usable
+* call (`SESSION_REVOKED`, `INVALID_SESSION_TOKEN`, `INVALID_SESSION`). The
+* HTTP client runs it for calls that send the session in the
+* `Authorization` header, `/v1/client/auth/me` and `/identifiers`
+* included; `withBodySession` runs it for the link and unlink calls, which
+* send the session in their body. True when a usable
 * session for the user the call was sent for is stored afterwards, so the
 * call is sent once more as that user:
 *   - a link in flight on this device stores the pair it returns, which is
@@ -3067,6 +3098,40 @@ async function recoverRefusedSession(state_, usedToken, usedUserId) {
 	return usableForCaller(state_.identity.getSessionToken());
 }
 /**
+* Send an auth call that carries the stored session token in its body
+* (`/link`, `/unlink`). `send` builds the request from the token it is
+* given. When the server refuses that token, the session recovers through
+* `recoverRefusedSession` (one refresh shared with every other refused
+* call) and the call is sent once more with the recovered token; a second
+* refusal reaches the app. A link waits here outside `trackLink`: its own
+* failed attempt has already left `linksInflight` (the removal is the first
+* reaction on that promise), so recovery never waits on itself.
+*/
+async function withBodySession(state_, send) {
+	const usedToken = state_.identity.getSessionToken();
+	if (!usedToken) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
+	const usedUserId = state_.identity.getAppUserId();
+	try {
+		return await send(usedToken);
+	} catch (err) {
+		if (!isSessionRefusedError(err)) throw err;
+		if (!await recoverRefusedSession(state_, usedToken, usedUserId)) throw err;
+		const recovered = state_.identity.getSessionToken();
+		if (!recovered) throw err;
+		return send(recovered);
+	}
+}
+/**
+* Before a read of the current session (`me`, `getSession`,
+* `getCurrentIdentifiers`) while no session token is stored: wait for the
+* launch restore or sign-in in flight, so a check made at launch sees the
+* session it restores.
+*/
+async function settleSessionInFlight(state_) {
+	if (state_.identity.getSessionToken() || !state_.anonSignInInflight) return;
+	await state_.anonSignInInflight.catch(() => {});
+}
+/**
 * Continue the stored session with its refresh token. True when it did.
 * False when there is no refresh token, or the server rejected it: the
 * session is then cleared (the anonymous id rotates unless the session was
@@ -3177,7 +3242,10 @@ async function refreshSessionOnce(state_) {
 * account's rotated anonymous id is adopted.
 */
 function postLink(state_, body) {
-	return trackLink(state_, postLinkOnce(state_, body));
+	return withBodySession(state_, (sessionToken) => trackLink(state_, postLinkOnce(state_, {
+		...body,
+		session_token: sessionToken
+	})));
 }
 async function postLinkOnce(state_, body) {
 	const env = await state_.http.post(P.authLink, {
@@ -3213,12 +3281,10 @@ async function postUserNoRotate(state_, path, body) {
 }
 async function unlinkProvider(provider) {
 	const s = getState();
-	const sessionToken = s.identity.getSessionToken();
-	if (!sessionToken) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
-	return postUserNoRotate(s, P.authUnlink, {
+	return withBodySession(s, (sessionToken) => postUserNoRotate(s, P.authUnlink, {
 		provider,
 		session_token: sessionToken
-	});
+	}));
 }
 function requireEmail(email) {
 	const trimmed = email.trim();
@@ -3732,52 +3798,38 @@ const Amba = {
 			if (providerTrimmed === "") throw new AmbaApiError("VALIDATION_ERROR", "provider must not be empty");
 			if (typeof credential !== "string" || credential.trim() === "") throw new AmbaApiError("VALIDATION_ERROR", "credential must not be empty");
 			const s = getState();
-			const sessionToken = s.identity.getSessionToken();
-			if (!sessionToken) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
-			return trackLink(s, postAuth(s, P.authLink, {
+			return withBodySession(s, (sessionToken) => trackLink(s, postAuth(s, P.authLink, {
 				provider: providerTrimmed,
 				token: credential,
 				session_token: sessionToken,
 				...nonceField(options)
-			}));
+			})));
 		},
 		linkSmsOtp: async (phone, code) => {
 			requireE164Phone(phone);
 			requireOtpCode(code);
-			const s = getState();
-			const sessionToken = s.identity.getSessionToken();
-			if (!sessionToken) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
-			return postLink(s, {
+			return postLink(getState(), {
 				provider: "sms_otp",
 				phone,
-				code,
-				session_token: sessionToken
+				code
 			});
 		},
 		linkEmailOtp: async (email, code) => {
 			requireEmail(email);
 			requireOtpCode(code);
-			const s = getState();
-			const sessionToken = s.identity.getSessionToken();
-			if (!sessionToken) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
-			return postLink(s, {
+			return postLink(getState(), {
 				provider: "email_otp",
 				email,
-				code,
-				session_token: sessionToken
+				code
 			});
 		},
 		linkEmailPassword: async (email, password) => {
 			requireEmail(email);
 			requirePassword(password);
-			const s = getState();
-			const sessionToken = s.identity.getSessionToken();
-			if (!sessionToken) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
-			return postLink(s, {
+			return postLink(getState(), {
 				provider: "email_password",
 				email,
-				password,
-				session_token: sessionToken
+				password
 			});
 		},
 		unlinkSmsOtp: async () => unlinkProvider("sms_otp"),
@@ -3786,6 +3838,7 @@ const Amba = {
 		unlinkGoogle: async () => unlinkProvider("google"),
 		getCurrentIdentifiers: async () => {
 			const s = getState();
+			await settleSessionInFlight(s);
 			if (!s.identity.getSessionToken()) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
 			return (await s.http.get(P.authIdentifiers)).data.identifiers;
 		},
@@ -3812,13 +3865,20 @@ const Amba = {
 		refresh: async () => refreshSession(getState()),
 		me: async () => {
 			const s = getState();
+			await settleSessionInFlight(s);
 			if (!s.identity.getSessionToken()) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
 			return normalizeUserAuthProviders((await s.http.get(P.authMe)).data);
 		},
 		getSession: async () => {
 			const s = getState();
+			await settleSessionInFlight(s);
 			if (!s.identity.isAuthenticated()) return null;
-			return snapshotSession(normalizeUserAuthProviders((await s.http.get(P.authMe)).data));
+			try {
+				return snapshotSession(normalizeUserAuthProviders((await s.http.get(P.authMe)).data));
+			} catch (err) {
+				if (isSessionRefusedError(err) && !s.identity.isAuthenticated()) return null;
+				throw err;
+			}
 		},
 		getAnonymousId: async () => {
 			return getState().identity.getAnonymousId();