@asgardeo/auth-spa 0.2.13 → 0.2.17

package/src/clients/main-thread-client.ts

@@ -33,6 +33,7 @@ import {
 import {
     CHECK_SESSION_SIGNED_IN,
     CHECK_SESSION_SIGNED_OUT,
+    CUSTOM_GRANT_CONFIG,
     ERROR,
     ERROR_DESCRIPTION,
     PROMPT_NONE_IFRAME,
@@ -86,13 +87,16 @@ export const MainThreadClient = async (
     );
 
     const _httpClient: HttpClientInstance = HttpClient.getInstance();
+    let _isHttpHandlerEnabled: boolean = true;
+    let _httpErrorCallback: (error: HttpError) => void | Promise<void>;
+    let _httpFinishCallback: () => void;
 
     const attachToken = async (request: HttpRequestConfig): Promise<void> => {
         const requestConfig = { attachToken: true, ...request };
         if (requestConfig.attachToken) {
             request.headers = {
                 ...request.headers,
-                Authorization: `Bearer ${ await _authenticationClient.getAccessToken() }`
+                Authorization: `Bearer ${await _authenticationClient.getAccessToken()}`
             };
         }
     };
@@ -109,17 +113,18 @@ export const MainThreadClient = async (
 
     const setHttpRequestFinishCallback = (callback: () => void): void => {
         _httpClient?.setHttpRequestFinishCallback && _httpClient.setHttpRequestFinishCallback(callback);
+        _httpFinishCallback = callback;
     };
 
-    const setHttpRequestErrorCallback = (callback: (error: HttpError) => void): void => {
-        _httpClient?.setHttpRequestErrorCallback && _httpClient.setHttpRequestErrorCallback(callback);
+    const setHttpRequestErrorCallback = (callback: (error: HttpError) => void | Promise<void>): void => {
+        _httpErrorCallback = callback;
     };
 
     const httpRequest = async (requestConfig: HttpRequestConfig): Promise<HttpResponse> => {
         let matches = false;
         const config = await _dataLayer.getConfigData();
 
-        for (const baseUrl of [ ...((await config?.resourceServerURLs) ?? []), config?.serverOrigin ]) {
+        for (const baseUrl of [...((await config?.resourceServerURLs) ?? []), config?.serverOrigin]) {
             if (requestConfig?.url?.startsWith(baseUrl)) {
                 matches = true;
 
@@ -133,32 +138,61 @@ export const MainThreadClient = async (
                 .then((response: HttpResponse) => {
                     return Promise.resolve(response);
                 })
-                .catch((error: HttpError) => {
-                    if (error?.response?.status === 401) {
-                        return _authenticationClient
-                            .refreshAccessToken()
-                            .then(() => {
-                                return _httpClient
-                                    .request(requestConfig)
-                                    .then((response) => {
-                                        return Promise.resolve(response);
-                                    })
-                                    .catch((error) => {
-                                        return Promise.reject(error);
-                                    });
-                            })
-                            .catch((refreshError) => {
-                                return Promise.reject(
-                                    new AsgardeoSPAException(
-                                        "MAIN_THREAD_CLIENT-HR-ES01",
-                                        "main-thread-client",
-                                        "httpRequest",
-                                        "",
-                                        "",
-                                        refreshError
-                                    )
-                                );
-                            });
+                .catch(async (error: HttpError) => {
+                    if (error?.response?.status === 401 || !error?.response) {
+                        // Try to refresh the token
+                        let refreshTokenResponse;
+                        try {
+                            refreshTokenResponse = await refreshAccessToken();
+                        } catch (refreshError: any) {
+                            if (_isHttpHandlerEnabled) {
+                                if (typeof _httpErrorCallback === "function") {
+                                    await _httpErrorCallback(error);
+                                }
+                                if (typeof _httpFinishCallback === "function") {
+                                    _httpFinishCallback();
+                                }
+                            }
+
+                            return Promise.reject(
+                                new AsgardeoSPAException(
+                                    "MAIN_THREAD_CLIENT-HR-ES01",
+                                    "main-thread-client",
+                                    "httpRequest",
+                                    "",
+                                    "",
+                                    refreshError
+                                )
+                            );
+                        }
+
+                        // Retry the request after refreshing the token
+                        if (refreshTokenResponse) {
+                            try {
+                                const httpResponse = await _httpClient.request(requestConfig);
+                                return Promise.resolve(httpResponse);
+                            } catch (error: any) {
+                                if (_isHttpHandlerEnabled) {
+                                    if (typeof _httpErrorCallback === "function") {
+                                        await _httpErrorCallback(error);
+                                    }
+                                    if (typeof _httpFinishCallback === "function") {
+                                        _httpFinishCallback();
+                                    }
+                                }
+
+                                return Promise.reject(error);
+                            }
+                        }
+                    }
+
+                    if (_isHttpHandlerEnabled) {
+                        if (typeof _httpErrorCallback === "function") {
+                            await _httpErrorCallback(error);
+                        }
+                        if (typeof _httpFinishCallback === "function") {
+                            _httpFinishCallback();
+                        }
                     }
 
                     return Promise.reject(error);
@@ -171,8 +205,8 @@ export const MainThreadClient = async (
                     "httpRequest",
                     "Request to the provided endpoint is prohibited.",
                     "Requests can only be sent to resource servers specified by the `resourceServerURLs`" +
-                    " attribute while initializing the SDK. The specified endpoint in this request " +
-                    "cannot be found among the `resourceServerURLs`"
+                        " attribute while initializing the SDK. The specified endpoint in this request " +
+                        "cannot be found among the `resourceServerURLs`"
                 )
             );
         }
@@ -185,7 +219,7 @@ export const MainThreadClient = async (
         for (const requestConfig of requestConfigs) {
             let urlMatches = false;
 
-            for (const baseUrl of [ ...((await config)?.resourceServerURLs ?? []), config?.serverOrigin ]) {
+            for (const baseUrl of [...((await config)?.resourceServerURLs ?? []), config?.serverOrigin]) {
                 if (requestConfig.url?.startsWith(baseUrl)) {
                     urlMatches = true;
 
@@ -214,35 +248,62 @@ export const MainThreadClient = async (
                     .then((responses: HttpResponse[]) => {
                         return Promise.resolve(responses);
                     })
-                    .catch((error: HttpError) => {
-                        if (error?.response?.status === 401) {
-                            return _authenticationClient
-                                .refreshAccessToken()
-                                .then(() => {
-                                    return (
-                                        _httpClient.all &&
-                                        _httpClient
-                                            .all(requests)
-                                            .then((response) => {
-                                                return Promise.resolve(response);
-                                            })
-                                            .catch((error) => {
-                                                return Promise.reject(error);
-                                            })
-                                    );
-                                })
-                                .catch((refreshError) => {
-                                    return Promise.reject(
-                                        new AsgardeoSPAException(
-                                            "MAIN_THREAD_CLIENT-HRA-ES01",
-                                            "main-thread-client",
-                                            "httpRequestAll",
-                                            "",
-                                            "",
-                                            refreshError
-                                        )
-                                    );
-                                });
+                    .catch(async (error: HttpError) => {
+                        if (error?.response?.status === 401 || !error?.response) {
+                            let refreshTokenResponse;
+                            try {
+                                refreshTokenResponse = await _authenticationClient.refreshAccessToken();
+                            } catch (refreshError: any) {
+                                if (_isHttpHandlerEnabled) {
+                                    if (typeof _httpErrorCallback === "function") {
+                                        await _httpErrorCallback(error);
+                                    }
+                                    if (typeof _httpFinishCallback === "function") {
+                                        _httpFinishCallback();
+                                    }
+                                }
+
+                                return Promise.reject(
+                                    new AsgardeoSPAException(
+                                        "MAIN_THREAD_CLIENT-HRA-ES01",
+                                        "main-thread-client",
+                                        "httpRequestAll",
+                                        "",
+                                        "",
+                                        refreshError
+                                    )
+                                );
+                            }
+
+                            if (refreshTokenResponse) {
+                                return _httpClient.all &&
+                                    _httpClient
+                                        .all(requests)
+                                        .then((response) => {
+                                            return Promise.resolve(response);
+                                        })
+                                        .catch(async (error) => {
+                                            if (_isHttpHandlerEnabled) {
+                                                if (typeof _httpErrorCallback === "function") {
+                                                    await _httpErrorCallback(error);
+                                                }
+                                                if (typeof _httpFinishCallback === "function") {
+                                                    _httpFinishCallback();
+                                                }
+                                            }
+
+                                            return Promise.reject(error);
+                                        });
+                            }
+                        }
+
+                        if (_isHttpHandlerEnabled) {
+                            if (typeof _httpErrorCallback === "function") {
+                                await _httpErrorCallback(error);
+                            }
+                            if (typeof _httpFinishCallback === "function") {
+                                _httpFinishCallback();
+                            }
                         }
 
                         return Promise.reject(error);
@@ -256,8 +317,8 @@ export const MainThreadClient = async (
                     "httpRequest",
                     "Request to the provided endpoint is prohibited.",
                     "Requests can only be sent to resource servers specified by the `resourceServerURLs`" +
-                    " attribute while initializing the SDK. The specified endpoint in this request " +
-                    "cannot be found among the `resourceServerURLs`"
+                        " attribute while initializing the SDK. The specified endpoint in this request " +
+                        "cannot be found among the `resourceServerURLs`"
                 )
             );
         }
@@ -269,12 +330,14 @@ export const MainThreadClient = async (
 
     const enableHttpHandler = (): boolean => {
         _httpClient?.enableHandler && _httpClient.enableHandler();
+        _isHttpHandlerEnabled = true;
 
         return true;
     };
 
     const disableHttpHandler = (): boolean => {
         _httpClient?.disableHandler && _httpClient.disableHandler();
+        _isHttpHandlerEnabled = false;
 
         return true;
     };
@@ -315,6 +378,7 @@ export const MainThreadClient = async (
                 displayName: "",
                 email: "",
                 sessionState: "",
+                sub: "",
                 tenantDomain: "",
                 username: ""
             });
@@ -383,6 +447,7 @@ export const MainThreadClient = async (
                 displayName: "",
                 email: "",
                 sessionState: "",
+                sub: "",
                 tenantDomain: "",
                 username: ""
             });
@@ -421,7 +486,9 @@ export const MainThreadClient = async (
                 }
             }
         }
-
+        if(config.shouldReplayAfterRefresh) {
+            _dataLayer.setTemporaryDataParameter(CUSTOM_GRANT_CONFIG, JSON.stringify(config));
+        }
         if (useDefaultEndpoint || matches) {
             return _authenticationClient
                 .requestCustomGrant(config)
@@ -445,24 +512,26 @@ export const MainThreadClient = async (
                     "requestCustomGrant",
                     "Request to the provided endpoint is prohibited.",
                     "Requests can only be sent to resource servers specified by the `resourceServerURLs`" +
-                    " attribute while initializing the SDK. The specified token endpoint in this request " +
-                    "cannot be found among the `resourceServerURLs`"
+                        " attribute while initializing the SDK. The specified token endpoint in this request " +
+                        "cannot be found among the `resourceServerURLs`"
                 )
             );
         }
     };
 
-    const refreshAccessToken = (): Promise<BasicUserInfo> => {
-        return _authenticationClient
-            .refreshAccessToken()
-            .then(() => {
-                _spaHelper.refreshAccessTokenAutomatically();
+    const refreshAccessToken = async (): Promise<BasicUserInfo> => {
+        try {
+            await _authenticationClient.refreshAccessToken();
+            const customGrantConfig = await getCustomGrantConfigData();
+            if (customGrantConfig) {
+                await requestCustomGrant(customGrantConfig);
+            }
+            _spaHelper.refreshAccessTokenAutomatically();
 
-                return _authenticationClient.getBasicUserInfo();
-            })
-            .catch((error) => {
-                return Promise.reject(error);
-            });
+            return _authenticationClient.getBasicUserInfo();
+        } catch (error) {
+            return Promise.reject(error);
+        }
     };
 
     const revokeAccessToken = (): Promise<boolean> => {
@@ -529,6 +598,7 @@ export const MainThreadClient = async (
                 displayName: "",
                 email: "",
                 sessionState: "",
+                sub: "",
                 tenantDomain: "",
                 username: ""
             });
@@ -640,6 +710,15 @@ export const MainThreadClient = async (
         }
     };
 
+    const getCustomGrantConfigData = async (): Promise<AuthClientConfig<CustomGrantConfig> | null> => {
+        const configString =  await _dataLayer.getTemporaryDataParameter(CUSTOM_GRANT_CONFIG);
+        if(configString) {
+            return JSON.parse(configString as string);
+        } else {
+            return null
+        }
+    };
+
     return {
         disableHttpHandler,
         enableHttpHandler,

package/src/clients/web-worker-client.ts

@@ -51,7 +51,6 @@ import {
     REFRESH_ACCESS_TOKEN,
     REQUEST_ACCESS_TOKEN,
     REQUEST_CUSTOM_GRANT,
-    REQUEST_ERROR,
     REQUEST_FINISH,
     REQUEST_START,
     REQUEST_SUCCESS,
@@ -88,6 +87,8 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
      * API request time out.
      */
     const _requestTimeout: number = config?.requestTimeout ?? 60000;
+    let _isHttpHandlerEnabled: boolean = true;
+
     const _sessionManagementHelper = SessionManagementHelper(
         async () => {
             const message: Message<string> = {
@@ -186,7 +187,16 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
             .then((response) => {
                 return Promise.resolve(response);
             })
-            .catch((error) => {
+            .catch(async (error) => {
+                if (_isHttpHandlerEnabled) {
+                    if (typeof httpClientHandlers.requestErrorCallback === "function") {
+                        await httpClientHandlers.requestErrorCallback(error);
+                    }
+                    if (typeof httpClientHandlers.requestFinishCallback === "function") {
+                        httpClientHandlers.requestFinishCallback();
+                    }
+                }
+
                 return Promise.reject(error);
             });
     };
@@ -210,7 +220,16 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
             .then((response) => {
                 return Promise.resolve(response);
             })
-            .catch((error) => {
+            .catch(async (error) => {
+                if (_isHttpHandlerEnabled) {
+                    if (typeof httpClientHandlers.requestErrorCallback === "function") {
+                        await httpClientHandlers.requestErrorCallback(error);
+                    }
+                    if (typeof httpClientHandlers.requestFinishCallback === "function") {
+                        httpClientHandlers.requestFinishCallback();
+                    }
+                }
+
                 return Promise.reject(error);
             });
     };
@@ -221,6 +240,8 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
         };
         return communicate<null, null>(message)
             .then(() => {
+                _isHttpHandlerEnabled = true;
+
                 return Promise.resolve(true);
             })
             .catch((error) => {
@@ -234,6 +255,8 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
         };
         return communicate<null, null>(message)
             .then(() => {
+                _isHttpHandlerEnabled = false;
+
                 return Promise.resolve(true);
             })
             .catch((error) => {
@@ -250,19 +273,17 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
      *
      */
     const initialize = (): Promise<boolean> => {
-        httpClientHandlers = {
-            requestErrorCallback: () => null,
-            requestFinishCallback: () => null,
-            requestStartCallback: () => null,
-            requestSuccessCallback: () => null
-        };
+        if (!httpClientHandlers) {
+            httpClientHandlers = {
+                requestErrorCallback: () => Promise.resolve(),
+                requestFinishCallback: () => null,
+                requestStartCallback: () => null,
+                requestSuccessCallback: () => null
+            };
+        }
 
         worker.onmessage = ({ data }) => {
             switch (data.type) {
-                case REQUEST_ERROR:
-                    httpClientHandlers?.requestErrorCallback &&
-                        httpClientHandlers?.requestErrorCallback(data.data ? JSON.parse(data.data) : null);
-                    break;
                 case REQUEST_FINISH:
                     httpClientHandlers?.requestFinishCallback && httpClientHandlers?.requestFinishCallback();
                     break;
@@ -342,6 +363,7 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
                 displayName: "",
                 email: "",
                 sessionState: "",
+                sub: "",
                 tenantDomain: "",
                 username: ""
             });
@@ -394,16 +416,18 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
                 }
 
                 if (data?.type == CHECK_SESSION_SIGNED_IN && data?.data?.code) {
-                    requestAccessToken(data?.data?.code, data?.data?.sessionState).then((response: BasicUserInfo) => {
-                        window.removeEventListener("message", listenToPromptNoneIFrame);
-                        resolve(response);
-                    }).catch((error) => {
-                        window.removeEventListener("message", listenToPromptNoneIFrame);
-                        reject(error);
-                    }).finally((() => {
-                        clearTimeout(timer);
-                    }));
-
+                    requestAccessToken(data?.data?.code, data?.data?.sessionState)
+                        .then((response: BasicUserInfo) => {
+                            window.removeEventListener("message", listenToPromptNoneIFrame);
+                            resolve(response);
+                        })
+                        .catch((error) => {
+                            window.removeEventListener("message", listenToPromptNoneIFrame);
+                            reject(error);
+                        })
+                        .finally(() => {
+                            clearTimeout(timer);
+                        });
                 }
             };
 
@@ -480,6 +504,7 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
                 displayName: "",
                 email: "",
                 sessionState: "",
+                sub: "",
                 tenantDomain: "",
                 username: ""
             });
@@ -553,6 +578,7 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
                     displayName: "",
                     email: "",
                     sessionState: "",
+                    sub: "",
                     tenantDomain: "",
                     username: ""
                 });
@@ -717,7 +743,7 @@ export const WebWorkerClient = (config: AuthClientConfig<WebWorkerClientConfig>)
         }
     };
 
-    const setHttpRequestErrorCallback = (callback: (response: HttpError) => void): void => {
+    const setHttpRequestErrorCallback = (callback: (response: HttpError) => void | Promise<void>): void => {
         if (callback && typeof callback === "function") {
             httpClientHandlers.requestErrorCallback = callback;
         }

package/src/constants/parameters.ts

@@ -18,3 +18,4 @@
 
 export const ERROR = "error";
 export const ERROR_DESCRIPTION = "error_description";
+export const CUSTOM_GRANT_CONFIG = "custom_grant_config";

package/src/models/client.ts

@@ -38,7 +38,7 @@ export interface MainThreadClientInterface {
     setHttpRequestStartCallback(callback: () => void): void;
     setHttpRequestSuccessCallback(callback: (response: HttpResponse) => void): void;
     setHttpRequestFinishCallback(callback: () => void): void;
-    setHttpRequestErrorCallback(callback: (error: HttpError) => void): void;
+    setHttpRequestErrorCallback(callback: (error: HttpError) => void | Promise<void>): void;
     httpRequest(config: HttpRequestConfig): Promise<HttpResponse>;
     httpRequestAll(config: HttpRequestConfig[]): Promise<HttpResponse[] | undefined>;
     getHttpClient(): HttpClientInstance;
@@ -85,7 +85,7 @@ export interface WebWorkerClientInterface {
     getIDToken(): Promise<string>;
     isAuthenticated(): Promise<boolean>;
     setHttpRequestSuccessCallback(callback: (response: HttpResponse) => void): void;
-    setHttpRequestErrorCallback(callback: (response: HttpError) => void): void;
+    setHttpRequestErrorCallback(callback: (response: HttpError) => void | Promise<void>): void;
     setHttpRequestStartCallback(callback: () => void): void;
     setHttpRequestFinishCallback(callback: () => void): void;
     refreshAccessToken(): Promise<BasicUserInfo>;

package/src/models/http-client.ts

@@ -22,7 +22,7 @@ import { HttpError, HttpResponse } from ".";
 export interface HttpClient {
     requestStartCallback: () => void;
     requestSuccessCallback: (response: HttpResponse) => void;
-    requestErrorCallback: (error: HttpError) => void;
+    requestErrorCallback: (error: HttpError) => void | Promise<void>;
     requestFinishCallback: () => void;
 }
 

package/src/models/web-worker.ts

@@ -24,7 +24,7 @@ import {
     DecodedIDTokenPayload,
     OIDCEndpoints
 } from "@asgardeo/auth-js";
-import { HttpError, HttpRequestConfig, HttpResponse, Message } from ".";
+import { HttpRequestConfig, HttpResponse, Message } from ".";
 import { AuthorizationResponse, WebWorkerClientConfig } from "..";
 
 interface WebWorkerEvent<T> extends MessageEvent {
@@ -39,7 +39,6 @@ export interface WebWorkerCoreInterface {
     setHttpRequestStartCallback(callback: () => void): void;
     setHttpRequestSuccessCallback(callback: (response: HttpResponse) => void): void;
     setHttpRequestFinishCallback(callback: () => void): void;
-    setHttpRequestErrorCallback(callback: (error: HttpError) => void): void;
     httpRequest(config: HttpRequestConfig): Promise<HttpResponse>;
     httpRequestAll(configs: HttpRequestConfig[]): Promise<HttpResponse[] | undefined>;
     enableHttpHandler(): void;

package/src/worker/client.worker.ts

@@ -35,7 +35,6 @@ import {
     REFRESH_ACCESS_TOKEN,
     REQUEST_ACCESS_TOKEN,
     REQUEST_CUSTOM_GRANT,
-    REQUEST_ERROR,
     REQUEST_FINISH,
     REQUEST_START,
     REQUEST_SUCCESS,
@@ -48,7 +47,6 @@ import {
 import { AsgardeoSPAException } from "../exception";
 import {
     AuthorizationResponse,
-    HttpError,
     HttpResponse,
     WebWorkerClass,
     WebWorkerClientConfig,
@@ -83,7 +81,6 @@ ctx.onmessage = async ({ data, ports }) => {
             try {
                 const config: AuthClientConfig<WebWorkerClientConfig> = { ...data.data };
                 webWorker = await WebWorkerCore(config);
-                webWorker.setHttpRequestErrorCallback(onRequestErrorCallback);
                 webWorker.setHttpRequestFinishCallback(onRequestFinishCallback);
                 webWorker.setHttpRequestStartCallback(onRequestStartCallback);
                 webWorker.setHttpRequestSuccessCallback(onRequestSuccessCallback);
@@ -279,22 +276,16 @@ ctx.onmessage = async ({ data, ports }) => {
     }
 };
 
-const onRequestStartCallback = () => {
+const onRequestStartCallback = (): void => {
     ctx.postMessage({ type: REQUEST_START });
 };
 
-const onRequestSuccessCallback = (response: HttpResponse) => {
+const onRequestSuccessCallback = (response: HttpResponse): void => {
     ctx.postMessage({ data: JSON.stringify(response ?? ""), type: REQUEST_SUCCESS });
 };
 
-const onRequestFinishCallback = () => {
+const onRequestFinishCallback = (): void => {
     ctx.postMessage({ type: REQUEST_FINISH });
 };
 
-const onRequestErrorCallback = (error: HttpError) => {
-    const errorObject: Partial<HttpError> = { ...error };
-    delete errorObject.toJSON;
-    ctx.postMessage({ data: JSON.stringify(errorObject ?? ""), type: REQUEST_ERROR });
-};
-
 export default {} as typeof Worker & { new (): Worker };