asma-helpers 0.2.49 → 0.3.0

package/src/helpers/generateSrvAuthBindings.ts

@@ -2,11 +2,12 @@ import axios, { type AxiosResponse, type ResponseType } from 'axios'
 import { EventBus } from 'asma-event-bus/lib/event-buss'
 import { EnvironmentEnums, parseJwt } from '..'
 
-let logoutsuccesfull = false
+//let logoutsuccesfull = false
 
-export const { dispatch, register: registerCallbackOnSrvAuthEvents } = EventBus<{ jwt_changed: {}; logout_event: {} }>(
-    'auth-bindings',
-)
+export const { dispatch: dispatchSrvAuthEvents, register: registerCallbackOnSrvAuthEvents } = EventBus<{
+    jwt_changed: {}
+    logout_event: {}
+}>('auth-bindings')
 
 export function generateSrvAuthBindings<FeatureEnums = never>(
     SRV_AUTH: () => string,
@@ -14,15 +15,11 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
     EnvironmentToOperateFn: () => string,
     logout?: () => void,
 ) {
-    // let logoutMfes: (() => void)[] = []
-
     if (logout) {
         registerCallbackOnSrvAuthEvents('logout_event', logout)
     }
 
     if (window.__ASMA__SHELL__?.auth_bindings) {
-        //window.__ASMA__SHELL__.logoutMfes = logoutMfes
-
         return window.__ASMA__SHELL__.auth_bindings as typeof auth_bindings
     }
 
@@ -30,21 +27,28 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
 
     let features: Set<FeatureEnums> | undefined
 
-    let parsed_jwt: any | undefined
+    let parsed_jwt: unknown | undefined
 
-    let fetchJwtPromise: Promise<{
+    /*  let fetchJwtPromise: Promise<{
         data: { message: string; token?: string; features?: FeatureEnums[]; errors: { message: string }[] }
-    }> | null = null
+    }> | null = null */
 
     const isJwtInvalid = () => (jwtToken && accessTokenHasExpired()) || !jwtToken
 
     const isJwtValid = () => !isJwtInvalid()
 
+    //function cancelRequest() {
+    //    return logoutsuccesfull
+    // }
+
+    const promiseRegistry: Record<string, Promise<unknown>> = <{}>{}
+
     async function srvAuthGet<R>(url: string, headers?: Record<string, string>) {
         if (DEVELOPMENT() && EnvironmentToOperateFn()) {
             if (EnvironmentToOperateFn() in EnvironmentEnums) {
                 url = `${url}&env=${EnvironmentToOperateFn()}`
 
+                // file deepcode ignore GlobalReplacementRegex: <it is intended to be replaced only first occurence>
                 url = url.includes('&') && !url.includes('?') ? url.replace('&', '?') : url
             } else {
                 console.warn(
@@ -57,13 +61,29 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
             }
         }
 
-        return axios.get<unknown, AxiosResponse<R>>(`${SRV_AUTH()}${url}`, {
-            headers: {
-                ...headers,
-                'asma-origin': window.location.origin,
-            },
-            withCredentials: true,
-        })
+        const promise =
+            promiseRegistry[url] ||
+            axios.get<unknown, AxiosResponse<R>>(`${SRV_AUTH()}${url}`, {
+                headers: {
+                    ...headers,
+                    'asma-origin': window.location.origin,
+                },
+                withCredentials: true,
+            })
+
+        if (!promiseRegistry[url]) {
+            promiseRegistry[url] = promise
+        }
+        try {
+            const res = await promise
+
+            return res as AxiosResponse<R, any>
+        } catch (e) {
+            console.error(e)
+            return
+        } finally {
+            delete promiseRegistry[url]
+        }
     }
 
     function accessTokenHasExpired(): boolean {
@@ -78,35 +98,43 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
     }
 
     async function signin(url: string, headers?: Record<string, string>) {
-        const { data } = await srvAuthGet<{ token: string; features: FeatureEnums[] }>(url, headers)
+        const data = await srvAuthGet<{ token: string; features: FeatureEnums[] }>(url, headers)
 
-        setAuthData(data)
+        setAuthData(data?.data)
 
-        logoutsuccesfull = false
+        // logoutsuccesfull = false
 
         return data
     }
 
+    const { unregister } = registerCallbackOnSrvAuthEvents('logout_event', () => {
+        setAuthData({ token: '' })
+
+        srvAuthGet('/signout')
+
+        unregister()
+    })
+
     async function signoutAuth() {
-        try {
-            setAuthData({ token: '' })
+        dispatchSrvAuthEvents('logout_event', {}, false)
 
-            await srvAuthGet('/signout')
-        } catch (e) {
-            console.error(e)
-        } finally {
-            dispatch('logout_event', {}, false)
-        }
+        // return srvAuthGet('/signout')
     }
+
     function getUserId(): string {
         return getParsedJwt()?.['user_id'] || '-1'
     }
 
-    function setAuthData(data: { token: string; features?: FeatureEnums[] }) {
-        jwtToken = data.token
-        features = new Set(data.features)
-        parsed_jwt = undefined
-        dispatch('jwt_changed', {}, false)
+    function setAuthData(data?: { token: string; features?: FeatureEnums[] }) {
+        if (data) {
+            jwtToken = data?.token
+
+            features = new Set(data.features)
+
+            parsed_jwt = parseJwt(jwtToken)
+        }
+
+        dispatchSrvAuthEvents('jwt_changed', {}, false)
     }
 
     function getJwtToken() {
@@ -140,33 +168,27 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
     }
 
     async function getNewJwtToken() {
-        if (logoutsuccesfull) return
         try {
-            if (!fetchJwtPromise) {
+            /*  if (!fetchJwtPromise) {
                 fetchJwtPromise = srvAuthGet('/token')
-            }
+            } */
 
-            const { data } = await fetchJwtPromise
+            const data = await srvAuthGet<{ errors?: string; token: string; features: FeatureEnums[] }>('/token')
 
-            if (!data || data.errors || data.message != 'Success' || !data.token) {
-                logout?.()
-                logoutsuccesfull = true
+            if (!data || data.data?.errors || !data.data.token) {
+                dispatchSrvAuthEvents('logout_event', {}, false)
 
-                //signoutAuth()
+                return
             }
 
-            setAuthData({ token: data.token || '', features: data.features || [] })
+            setAuthData({ token: data.data.token || '', features: data.data.features || [] })
         } catch (error) {
-            logout?.()
-            logoutsuccesfull = true
-            //signoutAuth()
+            dispatchSrvAuthEvents('logout_event', {}, false)
 
             setAuthData({ token: '', features: [] })
 
             console.error(error)
         } finally {
-            fetchJwtPromise = null
-
             return jwtToken
         }
     }
@@ -175,7 +197,7 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
         if (!parsed_jwt) {
             parsed_jwt = parseJwt<R>(jwtToken)
         }
-        return parsed_jwt
+        return parsed_jwt as R
     }
     function getFeatures() {
         return features
@@ -199,9 +221,14 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
         setReqConfig,
         getJwtTokenAsync,
         getNewJwtToken,
+        /**
+         * @deprecated use registerCallbackOnSrvAuthEvents directly
+         */
+        registerOnJwtChanges: registerCallbackOnSrvAuthEvents,
         getUserId,
         getParsedJwt,
         getJwtToken,
+        // cancelRequest,
         accessTokenHasExpired,
     }
     window.__ASMA__SHELL__ = window.__ASMA__SHELL__ || {}
@@ -212,11 +239,7 @@ export function generateSrvAuthBindings<FeatureEnums = never>(
 }
 /**
  * @deprecated use generateSrvAuthBindings
- * @param SRV_AUTH
- * @param DEVELOPMENT
- * @param ENVIRONMENT_TO_OPERATE
- * @param logout
- * @returns
+ *
  */
 export function generateSrvAuthBindingsMicroApp(
     SRV_AUTH: () => string,

package/src/helpers/parseJwt.ts

@@ -1,11 +1,11 @@
 
 
-export function parseJwt<R>(jwtToken: string): R|undefined {
+export function parseJwt<R>(jwtToken: string){
     const base64Url = jwtToken?.split('.')[1]
 
-    if (base64Url === undefined) {
-        return {} as any
+    if (!base64Url) {
+        return 
     }
 
-    return JSON.parse(decodeURIComponent(escape(window.atob(base64Url))))
+    return JSON.parse(decodeURIComponent(escape(window.atob(base64Url)))) as R
 }