@schemavaults/auth-client-sdk 0.5.4 → 0.7.5

package/dist/auth-client.d.ts

@@ -113,7 +113,6 @@ export declare class SchemaVaultsAuthClient extends EventTarget implements ISche
      * @returns `UserData` | `null`
      */
     get currentUser(): UserData | null;
-    private assertHttpOnlyRefreshTokenCookieHasAccompanyingMarkerCookie;
     private handleSuccessfulExchangeAuthTokensResponse;
     private exchangeAuthTokens;
     private uuid;
@@ -126,4 +125,5 @@ export declare class SchemaVaultsAuthClient extends EventTarget implements ISche
      */
     get successful_logout_redirect_uri(): string | undefined;
     supports(feature_name: string): boolean;
+    checkIfAuthenticatedWithServer(): Promise<UserData | null>;
 }

package/dist/auth-client.js

@@ -1,9 +1,13 @@
-import AuthenticateURLEncoder from "./lib/authenticate-url-encoder";
-import { PKCE_ProofKeyManager, requestTokensResultSchema, authorizationCodePOSTbody, refreshTokenPOSTbody, audienceSchema, } from "@schemavaults/auth-common";
+// auth-client.ts
+// @schemavaults/auth-client-sdk
+import { PKCE_ProofKeyManager, requestTokensResultSchema, audienceSchema, } from "@schemavaults/auth-common";
 import { sendAuthenticateRequest } from "./lib/send-authenticate-request";
 import { appIdSchema, SCHEMAVAULTS_AUTH_APP_DEFINITION, schemaVaultsAppEnvironmentSchema, } from "@schemavaults/app-definitions";
-import debugPrintTokensAsTable from "./lib/debugPrintTokensAsTable";
-import debugPrintUserDataAsTable from "./lib/debugPrintUserDataAsTable";
+import authenticateWithRedirect from "./lib/authenticate-with-redirect";
+import checkIfAuthenticatedWithServer from "./lib/check-if-authenticated-with-server";
+import exchangeAuthTokens from "./lib/exchange-auth-tokens";
+import assertHttpOnlyRefreshTokenCookieHasAccompanyingMarkerCookie from "./lib/assert-http-only-refresh-token-has-accompanying-expiry-marker";
+import handleSuccessfulAuthentication from "./lib/handle-successful-authentication";
 /**
  * The SchemaVaultsAuthClient is a client SDK for the SchemaVaults Auth Server
  * It is used to authenticate users, store tokens, and manage user data
@@ -238,105 +242,26 @@ export class SchemaVaultsAuthClient extends EventTarget {
         return code_challenge;
     }
     async authenticateWithRedirect(type) {
-        if (this.DEBUG) {
-            console.log(`[SchemaVaultsAuthClient] Authenticating with redirect (type "${type}")...`);
-        }
-        // This should be kept securely within the SDK
-        let code_verifier;
-        try {
-            code_verifier = PKCE_ProofKeyManager.createCodeVerifier();
-        }
-        catch (e) {
-            console.error("Failed to create code verifier to initialize PKCE challenge process: ", e);
-            throw new Error("Failed to create code verifier to initialize PKCE challenge process");
-        }
-        // Do some validation
-        if (typeof code_verifier !== "object" || !code_verifier) {
-            throw new TypeError("Expected generated 'code_verifier' to be an object!");
-        }
-        else if (typeof code_verifier.challenge_time !== "number") {
-            throw new TypeError("Expected generated 'code_verifier.challenge_time' to be a number!");
-        }
-        else if (typeof code_verifier.code_verifier !== "string") {
-            throw new TypeError("Expected generated 'code_verifier.code_verifier' to be a string!");
-        }
-        // This is sent to the auth server-- it's a hash of the code verifier
-        // https://datatracker.ietf.org/doc/html/rfc7636#section-4.2
-        let code_challenge;
-        try {
-            const new_code_challenge = await PKCE_ProofKeyManager.createCodeChallenge(code_verifier);
-            code_challenge = new_code_challenge;
-        }
-        catch (e) {
-            console.error("Auth client failed to create code challenge from code verifier object: ", e);
-            const errMsg = e instanceof Error && typeof e.message === "string"
-                ? e.message
-                : "Auth client encountered an unknown error while creating code challenge";
-            throw new Error(`Auth client failed to create code challenge from code verifier object (error: ${errMsg})`);
-        }
-        // Validate code challenge a bit
-        if (typeof code_challenge.challenge_time !== "number") {
-            throw new Error("Expected challenge_time to be set (from input code_verifier)");
-        }
-        else if (typeof code_challenge.code_challenge_method !== "string" ||
-            code_challenge.code_challenge_method !== "S256") {
-            throw new Error("Expected code_challenge_method to be set to S256");
-        }
-        else if (typeof code_challenge.code_challenge !== "string") {
-            throw new Error("Expected code_challenge to be set");
-        }
-        // Store the code verifier in a secure location
-        try {
-            this.storeCodeVerifier(code_verifier.code_verifier, code_challenge.challenge_time);
-        }
-        catch (e) {
-            console.error("Failed to store code verifier: ", e);
-            throw new Error("Failed to store code verifier!");
-        }
-        // If the authentication is successful, the auth server will redirect the user back to the client
-        // and the code_verifier will be used to prove that the client initiating the flow is the same as the client that the authorization server issued the code to
-        const app_id = this.app_id;
-        if (!app_id) {
-            console.error("App ID not set, but required for PKCE flow");
-            throw new Error("App ID not set, but required for PKCE flow");
-        }
-        // The user is about to be redirected to auth server. Where should they be redirected back to this app? (for PKCE flow)
-        const redirect_uri = this.authorize_uri;
-        if (typeof redirect_uri !== "string") {
-            throw new Error("A URL to redirect to when authentication is successful was not provided. Required for PKCE flow.");
-        }
-        if (this.DEBUG) {
-            console.log("[SchemaVaultsAuthClient] Attempting to build URL to open from client in order to start OAuth 2.0 PKCE flow with SchemaVaults Auth Server...");
-        }
-        // Redirect the user to the auth server
-        let authenticate_url;
-        try {
-            authenticate_url = AuthenticateURLEncoder.encode({
-                type,
-                code_challenge: code_challenge,
-                redirect_uri,
-                app_id,
-                auth_server_uri: this._authServerUri,
-                app_env: this.environment,
-            });
-        }
-        catch (e) {
-            console.error("Failed to build authenticate URL: ", e);
-            throw new Error("Failed to build authenticate URL (i.e. where to login/register url not found)");
-        }
-        if (this.DEBUG) {
-            console.log("[SchemaVaultsAuthClient] Redirecting to authenticate URL: ", authenticate_url);
-        }
-        try {
-            await this.adapter.redirect(authenticate_url);
-            return;
-        }
-        catch (e) {
-            console.error("Failed to redirect to authentication server using client adapter: ", e);
-            throw new Error("Failed to redirect to authentication server");
-        }
+        if (!this.authorize_uri ||
+            typeof this.authorize_uri !== "string" ||
+            this.authorize_uri.length === 0) {
+            throw new TypeError("Failed to resolve 'authorize_uri'!");
+        }
+        return await authenticateWithRedirect({
+            type,
+            adapter: this.adapter,
+            auth_server_uri: this._authServerUri,
+            client_app_id: this._app_id,
+            storeCodeVerifier: this.storeCodeVerifier.bind(this),
+            environment: this.environment,
+            authorize_uri: this.authorize_uri,
+            debug: this.debug,
+        });
     }
     async login() {
+        if (this.isClientForAuthServer) {
+            return await this.adapter.redirect("/auth/login");
+        }
         if (this.DEBUG) {
             console.log("[SchemaVaultsAuthClient] Attempting to sign in with redirect...");
         }
@@ -351,6 +276,9 @@ export class SchemaVaultsAuthClient extends EventTarget {
         }
     } // login()
     async register() {
+        if (this.isClientForAuthServer) {
+            return await this.adapter.redirect("/auth/register");
+        }
         if (this.DEBUG) {
             console.log("[SchemaVaultsAuthClient] Attempting to register with redirect...");
         }
@@ -436,257 +364,22 @@ export class SchemaVaultsAuthClient extends EventTarget {
         return codeVerifiers;
     } // loadSavedAuthorizationCodeVerifiers()
     async handleSuccessfulAuthentication(authorization_code, challenge_time, code_verifier) {
-        const debug = this.DEBUG;
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient::handleSuccessfulAuthentication]" +
-                " " +
-                "Handling successful authentication...");
-        }
-        if (!authorization_code) {
-            throw new Error("Missing authorization code");
-        }
-        else if (typeof authorization_code !== "string" ||
-            authorization_code.length === 0) {
-            throw new TypeError("Expected 'authorization_code' to be a non-empty string!");
-        }
-        if (!challenge_time || typeof challenge_time !== "number") {
-            throw new Error("Invalid challenge_time");
-        }
-        const time_elapsed_since_challenge_time = Date.now() - challenge_time;
-        if (time_elapsed_since_challenge_time <= 0) {
-            throw new Error("Expected challenge time to be in the past");
-        }
-        if (time_elapsed_since_challenge_time > PKCE_ProofKeyManager.max_age) {
-            console.error("[SchemaVaultsAuthClient::handleSuccessfulAuthentication] Code verifier has expired based on challenge time");
-            if (this.debug) {
-                try {
-                    console.table({
-                        challenge_time,
-                        current_time: Date.now(),
-                        time_elapsed: time_elapsed_since_challenge_time,
-                        max_age: PKCE_ProofKeyManager.max_age,
-                    });
-                }
-                catch (e) {
-                    void e; /** no-op */
-                }
-            }
-            throw new Error("Code verifier has expired");
-        }
-        // The auth server will redirect the user back to the client
-        // The client will have a code in the query parameters
-        // The client will use the code to get an access token
-        // PKCE: The client will use the code_verifier to prove that it is the same client
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient] " +
-                "Attempting to load code verifier to prove authorization code validity...");
-        }
-        const cached_code_verifier = code_verifier ?? this.loadCodeVerifier(challenge_time);
-        if (!cached_code_verifier) {
-            const errorMessage = `[SchemaVaultsAuthClient] Failed to load code_verifier at challenge_time=${challenge_time}`;
-            console.error(errorMessage);
-            throw new Error(errorMessage);
-        }
-        cached_code_verifier;
-        const shouldClearCodeVerifierAfterLoad = this.environment !== "development";
-        if (shouldClearCodeVerifierAfterLoad) {
-            // Clear the code verifier from storage
-            try {
-                if (debug) {
-                    console.log("[SchemaVaultsAuthClient] " +
-                        "Code verifier was retrieved from storage, now clearing code verifier at challenge time: ", challenge_time);
-                }
-                this.adapter.clearCodeVerifier(challenge_time);
-                if (debug) {
-                    console.log("[SchemaVaultsAuthClient] Cleared code verifiers from storage");
-                }
-            }
-            catch (e) {
-                console.error("[SchemaVaultsAuthClient] Failed to clear code verifiers: ", e);
-                if (debug) {
-                    throw new Error("Failed to clear code verifiers");
-                }
-            }
-        }
-        else {
-            if (debug) {
-                console.log("[SchemaVaultsAuthClient] Not attempting to clear code verifiers in this app environment...");
-            }
-        }
-        // Get the endpoint to exchange the authorization code for an access token
-        // https://datatracker.ietf.org/doc/html/rfc7636#section-4.5
-        const token_endpoint = `${this.auth_server_uri}/api/auth/token/authorization_code`;
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient::handleSuccessfulAuthentication()] Token Endpoint: ", token_endpoint);
-        }
-        const client_app_id = this.app_id;
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient::handleSuccessfulAuthentication()] Client App ID: ", client_app_id);
-        }
-        let audience = this.defaultTokenAudiences;
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient::handleSuccessfulAuthentication()] Initial access token audience(s): ", audience);
-        }
-        if (!audience || (Array.isArray(audience) && audience.length === 0)) {
-            console.warn("[SchemaVaultsAuthClient::handleSuccessfulAuthentication()] No access token audience(s) set");
-            audience = [];
-        }
-        // Exchange the authorization code for an access token
-        let request_body;
-        try {
-            const parsed = await authorizationCodePOSTbody.safeParseAsync({
-                grant_type: "authorization_code",
-                code: authorization_code,
-                code_verifier: cached_code_verifier,
-                client_app_id,
-                audience,
-                challenge_time,
-            });
-            if (!parsed.success)
-                throw parsed.error;
-            request_body = parsed.data;
-        }
-        catch (e) {
-            console.error(e);
-            throw new Error("Failed to prepare request body for authorization grant request");
-        }
-        // Send the request to the auth server
-        // The auth server will hash the code_verifier and compare it to the code_challenge
-        let response;
-        try {
-            if (this.debug) {
-                console.log(`[SchemaVaultsAuthClient] Exchanging authorization code for access token; sending req body to token endpoint: "${token_endpoint}"`, request_body);
-            }
-            response = await this.adapter.sendPOSTRequest(token_endpoint, request_body, {});
-            if (this.debug) {
-                console.log("[SchemaVaultsAuthClient] Received response in attempt to exchange authorization code for access token: ", response);
-            }
-        }
-        catch (e) {
-            console.error("Failed to exchange authorization code for access token:", e);
-            throw new Error("Failed to exchange authorization code for access token");
-        }
-        if (!response || !response.ok || response.status !== 200) {
-            const errorMsg = "Failed to exchange authorization code for access token";
-            console.error(errorMsg);
-            throw new Error(errorMsg);
-        }
-        if (this.DEBUG) {
-            console.log("[SchemaVaultsAuthClient::handleSuccessfulAuthentication()] " +
-                "Successfully exchanged authorization code for token(s)");
-        }
-        let access_tokens;
-        let refresh_token;
-        let user;
-        try {
-            const tokens_data = await requestTokensResultSchema.safeParseAsync(response.data);
-            if (!tokens_data.success) {
-                console.error("[SchemaVaultsAuthClient::handleSuccessfulAuthentication()] " +
-                    "Failed to parse tokens from auth server response:", tokens_data.error);
-                throw new Error("Failed to parse tokens from auth server response");
-            }
-            else if (!tokens_data.data.success) {
-                throw new Error(tokens_data.data.message);
-            }
-            if (this.DEBUG) {
-                console.log("[SchemaVaultsAuthClient::handleSuccessfulAuthentication()] Success response data: ", tokens_data.data);
-            }
-            const { tokens, userData } = tokens_data.data;
-            if (!tokens) {
-                console.error("Did not receive tokens in response from auth server");
-                throw new Error("Did not receive tokens in response from auth server");
-            }
-            if (!tokens.access) {
-                console.error("Did not receive any access tokens in response from auth server");
-                throw new Error("Did not receive any access tokens in response from auth server");
-            }
-            if (!tokens.refresh ||
-                (typeof tokens.refresh !== "object" &&
-                    typeof tokens.refresh !== "string")) {
-                console.error("Did not receive (valid) refresh token in response from auth server.", `Type: ${typeof tokens.refresh}`, tokens.refresh);
-                throw new Error("Did not receive refresh token in response from auth server");
-            }
-            if (this.debug) {
-                debugPrintTokensAsTable(tokens);
-            }
-            access_tokens = tokens.access;
-            refresh_token = tokens.refresh;
-            if (!userData) {
-                console.error("Did not receive user data in response from auth server");
-                throw new Error("Did not receive user data in response from auth server");
-            }
-            else {
-                if (this.debug) {
-                    debugPrintUserDataAsTable(userData);
-                }
-            }
-            user = userData;
-        }
-        catch (e) {
-            let errorMessage = "Unknown error";
-            if (e instanceof Error) {
-                errorMessage = e.message;
-            }
-            console.error("Failed to parse tokens response: ", errorMessage);
-            throw new Error(`Failed to parse tokens response: ${errorMessage}`);
-        }
-        // Store refresh token
-        const doStoreReceivedRefreshToken = () => {
-            if (typeof refresh_token === "object" &&
-                refresh_token.type === "refresh") {
-                try {
-                    if (debug) {
-                        console.log("[SchemaVaultsAuthClient] Storing refresh token...");
-                    }
-                    this.storeRefreshToken(refresh_token);
-                    if (debug) {
-                        console.log("[SchemaVaultsAuthClient] Stored refresh token!");
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                    throw new Error("Failed to store refresh token");
-                }
-            }
-            else if (typeof refresh_token === "string" &&
-                refresh_token === "AS_HTTP_ONLY_COOKIE") {
-                this.assertHttpOnlyRefreshTokenCookieHasAccompanyingMarkerCookie();
-                if (debug) {
-                    console.log("[SchemaVaultsAuthClient] Detected HTTP-only cookie refresh token (accompanying-cookie).");
-                }
-                return;
-            }
-            else {
-                throw new TypeError("Invalid type for refresh token!");
-            }
-        };
-        doStoreReceivedRefreshToken();
-        // Store access tokens
-        this.storeMultipleAccessTokens(access_tokens);
-        try {
-            if (debug) {
-                console.log("[SchemaVaultsAuthClient] Storing user data...");
-            }
-            this.storeUserData(user);
-            if (debug) {
-                console.log("[SchemaVaultsAuthClient] Stored user data.");
-            }
-        }
-        catch (e) {
-            console.error("Failed to store user data: ", e);
-            throw new Error("Failed to store user data");
-        }
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient] Triggering auth state changed!");
-        }
-        this.triggerAuthStateChanged();
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient] Finished triggering auth state change.");
-        }
-        if (debug) {
-            console.log("[SchemaVaultsAuthClient] handleSuccessfulAuthentication success!");
-        }
-        return;
+        return await handleSuccessfulAuthentication({
+            authorization_code,
+            challenge_time,
+            code_verifier,
+            loadCodeVerifier: this.loadCodeVerifier.bind(this),
+            auth_server_uri: this.auth_server_uri,
+            client_app_id: this.app_id,
+            adapter: this.adapter,
+            storeUserData: this.storeUserData.bind(this),
+            storeRefreshToken: this.storeRefreshToken.bind(this),
+            storeMultipleAccessTokens: this.storeMultipleAccessTokens.bind(this),
+            environment: this.environment,
+            debug: this.DEBUG,
+            triggerAuthStateChanged: this.triggerAuthStateChanged.bind(this),
+            defaultTokenAudiences: this.defaultTokenAudiences,
+        });
     } // handleSuccessfulAuthentication()
     async logout() {
         if (this.debug) {
@@ -895,31 +588,7 @@ export class SchemaVaultsAuthClient extends EventTarget {
      * @description Getter that returns true/false based on whether a user is currently signed into their account
      */
     get isAuthenticated() {
-        if (this.DEBUG) {
-            console.log("[SchemaVaultsAuthClient::isAuthenticated] Checking whether auth client has a refresh token to see if authenticated...");
-        }
-        const refreshToken = this.getRefreshTokenFromCache();
-        if (refreshToken) {
-            if (this.DEBUG) {
-                console.log("[SchemaVaultsAuthClient::isAuthenticated] There is a refresh token stored, checking if it is expired...");
-            }
-            const refreshTokenExpiryTime = refreshToken.exp;
-            const now = this.getCurrentTimestamp();
-            if (now < refreshTokenExpiryTime) {
-                return true;
-            }
-            else {
-                if (this.DEBUG) {
-                    console.warn("[SchemaVaultsAuthClient::isAuthenticated] There is a refresh token stored, but it appears to be expired!");
-                }
-            }
-        }
-        else {
-            if (this.DEBUG) {
-                console.warn("[SchemaVaultsAuthClient::isAuthenticated] No refresh token found from cache!");
-            }
-        }
-        return false;
+        return this.adapter.hasRefreshToken();
     }
     /**
      * @name sendAuthenticateRequest
@@ -950,14 +619,6 @@ export class SchemaVaultsAuthClient extends EventTarget {
         const userData = this.getUserData();
         return userData;
     }
-    assertHttpOnlyRefreshTokenCookieHasAccompanyingMarkerCookie() {
-        if (typeof this.adapter.hasHttpOnlyRefreshToken === "function" &&
-            !this.adapter.hasHttpOnlyRefreshToken()) {
-            throw new Error("Adapter does not indicate having an HTTP-only refresh token after exchange," +
-                " " +
-                "despite response of AS_HTTP_ONLY_COOKIE!");
-        }
-    }
     async handleSuccessfulExchangeAuthTokensResponse(tokens_response) {
         const parsed_tokens_data = await requestTokensResultSchema.safeParseAsync(tokens_response);
         if (!parsed_tokens_data.success) {
@@ -991,7 +652,7 @@ export class SchemaVaultsAuthClient extends EventTarget {
             }
             else if (typeof tokens.refresh === "string" &&
                 tokens.refresh === "AS_HTTP_ONLY_COOKIE") {
-                this.assertHttpOnlyRefreshTokenCookieHasAccompanyingMarkerCookie();
+                assertHttpOnlyRefreshTokenCookieHasAccompanyingMarkerCookie(this.adapter);
                 if (this.debug) {
                     console.log("[SchemaVaultsAuthClient] Detected HTTP-only cookie refresh token from exchange response.");
                 }
@@ -1003,122 +664,17 @@ export class SchemaVaultsAuthClient extends EventTarget {
         return tokens;
     }
     async exchangeAuthTokens(refreshToken, audience, replaceRefreshToo) {
-        if (this.DEBUG) {
-            console.log("[SchemaVaultsAuthClient] Attempting to send request to exchange refresh token for access token...");
-        }
-        const token_endpoint = `${this.auth_server_uri}/api/auth/token/refresh_token`;
-        const client_app_id = this.app_id;
-        if (!audience && !replaceRefreshToo) {
-            throw new Error("Type of token to acquire not specified");
-        }
-        // Exchange the authorization code for an access token
-        let request_body;
-        try {
-            const parsed = await refreshTokenPOSTbody.safeParseAsync({
-                grant_type: "refresh_token",
-                client_app_id,
-                audience: audience ?? this.defaultTokenAudiences,
-                replaceRefreshToo: replaceRefreshToo ?? false,
-            });
-            if (!parsed.success) {
-                console.error(parsed.error);
-                throw new Error("Failed to parse tokens from exchange auth tokens POST request!");
-            }
-            request_body = parsed.data;
-        }
-        catch (e) {
-            if (this.DEBUG) {
-                console.error("Failed to prepare request body for authorization grant request: ", e);
-            }
-            throw new Error("Failed to prepare request body for authorization grant request");
-        }
-        const exchangeAuthTokensReqHeaders = {};
-        if (!refreshToken) {
-            throw new Error("Did not receive a refresh token to exchange for access token!");
-        }
-        if (typeof refreshToken === "object" && refreshToken.type === "refresh") {
-            if (typeof refreshToken.token !== "string" ||
-                refreshToken.token.length === 0) {
-                throw new TypeError("Expected 'token' to be a non-empty string!");
-            }
-            exchangeAuthTokensReqHeaders["Authorization"] =
-                `Bearer ${refreshToken.token}`;
-        }
-        else if (typeof refreshToken === "string" &&
-            refreshToken === "AS_HTTP_ONLY_COOKIE") {
-            const doesSupportHttpOnlyRefreshToken = this.adapter.doesSupportHttpOnlyRefreshToken;
-            if (typeof doesSupportHttpOnlyRefreshToken !== "function" ||
-                !doesSupportHttpOnlyRefreshToken()) {
-                throw new Error("Adapter does not support HTTP-only refresh tokens!");
-            }
-        }
-        else {
-            throw new Error("Did not receive a valid refresh token (or valid method of acquiring refresh token)");
-        }
-        if (this.DEBUG) {
-            console.log("[SchemaVaultsAuthClient::exchangeAuthTokens()] " +
-                `Sending POST request to "${token_endpoint}" with body & headers:`, request_body, exchangeAuthTokensReqHeaders);
-        }
-        let tokens_response_data;
-        try {
-            if (this.DEBUG) {
-                console.log(`POST => ${token_endpoint}`);
-            }
-            const response = await this.adapter.sendPOSTRequest(token_endpoint, 
-            // body
-            request_body, 
-            // headers
-            exchangeAuthTokensReqHeaders);
-            if (!response ||
-                typeof response !== "object" ||
-                response.status !== 200) {
-                if (response.status === 403 || response.status === 401) {
-                    console.error("401/403 error response from exchange token attempt, client is not logged in!");
-                    await this.logout();
-                }
-                throw new Error("HTTP request failed to exchange refresh token for access token(s) object");
-            }
-            const parsed_failed_tokens_result = await requestTokensResultSchema.safeParseAsync(response.data);
-            if (!parsed_failed_tokens_result.success) {
-                console.error("Failed to parse tokens response from server: ", parsed_failed_tokens_result.error);
-                throw new Error("Failed to parse tokens response from server!");
-            }
-            tokens_response_data = parsed_failed_tokens_result.data;
-        }
-        catch (e) {
-            if (this.DEBUG) {
-                console.error("[this.adapter.sendPOSTRequest] FAILED: ", e);
-                throw new Error("Failed to ");
-            }
-            if (e instanceof Error) {
-                const errMsg = e.message;
-                const eMsg = errMsg.toLowerCase();
-                if (eMsg.includes("expired") ||
-                    eMsg.includes("jwtexpired") ||
-                    eMsg.includes("err_jwt_expired")) {
-                    console.error("Refresh token appears to have expired!");
-                    throw new Error("Refresh token has expired!");
-                }
-            }
-            if (this.DEBUG) {
-                console.error("Failed to exchange refresh token for access token: ", e);
-            }
-            throw new Error("Failed to exchange refresh token for access token");
-        } // end of this.adapter.sendPOSTRequest catch block
-        try {
-            // Parse tokens from response JSON body
-            return await this.handleSuccessfulExchangeAuthTokensResponse(tokens_response_data);
-        }
-        catch (e) {
-            if (this.DEBUG) {
-                console.log("typeof e === ", typeof e);
-                if (e instanceof Error) {
-                    console.error("Parse tokens error message: ", e.message);
-                }
-                console.error("Failed to parse authentication tokens from exchange tokens POST request: ", e);
-            }
-            throw new Error("Failed to parse authentication tokens from exchange tokens POST request!");
-        }
+        return await exchangeAuthTokens({
+            refreshToken,
+            replaceRefreshToo,
+            audience: audience ?? this.defaultTokenAudiences,
+            logout: this.logout.bind(this),
+            debug: this.DEBUG,
+            handleSuccessfulExchangeAuthTokensResponse: this.handleSuccessfulExchangeAuthTokensResponse.bind(this),
+            client_app_id: this.app_id,
+            adapter: this.adapter,
+            auth_server_uri: this.auth_server_uri,
+        });
     } // exchangeAuthTokens()
     uuid() {
         let id;
@@ -1189,5 +745,12 @@ export class SchemaVaultsAuthClient extends EventTarget {
         }
         return false;
     }
+    async checkIfAuthenticatedWithServer() {
+        return await checkIfAuthenticatedWithServer({
+            adapter: this.adapter,
+            auth_server_uri: this.auth_server_uri,
+            client_app_id: this.app_id,
+        });
+    }
 }
 //# sourceMappingURL=auth-client.js.map