asma-helpers 0.2.33 → 0.2.35

package/src/helpers/generateGenqlClient.ts

@@ -1,108 +1,110 @@
-import type { AxiosRequestConfig } from 'axios'
-import type { ClientOptions, createClient } from '@genql/runtime'
-import { httpToWs } from './Config'
-//import { parseJwt } from '../helpers/parseJwt'
-
-interface CliOptions extends Omit<ClientOptions, 'url'> {
-    anonymous?: boolean
-}
-
-export function generateGenqlClient<T extends ReturnType<typeof createClient>>({
-    setReqConfig,
-    createClient,
-    serviceUrl,
-    path = '/v1/graphql',
-}: {
-    // jwt_exp: number
-    setReqConfig: () => Promise<AxiosRequestConfig<any>>
-    createClient: (options?: ClientOptions | undefined) => T
-    serviceUrl: () => string
-    path?: string
-}) {
-    // let jwt_exp = 0
-
-    let client: T | null = null
-
-    let wsClient: T | null = null
-
-    //function accessTokenHasExpired() {
-    //    const nowTime = Math.floor(new Date().getTime() / 1000)
-    //
-    //    //set exp time -20sec for token to be refreshed early
-    //    return jwt_exp - 10 <= nowTime
-    //}
-
-    async function getGenqlClient() {
-        if (/* accessTokenHasExpired() || */ client === null) {
-            client = await genqlClient()
-
-            return client
-        }
-
-        return client
-    }
-
-    //function resetGenqlClient() {
-    //    client = null
-    //}
-
-    // function setJwtExp(token?: string) {
-    //     if (!token) return
-    //
-    //     const parsed_jwt = parseJwt<{ exp: number }>(token)?.exp
-    //
-    //     jwt_exp = parsed_jwt || 0
-    // }
-
-    /**
-     *
-     * This is used for anonymous requests as well as authenticated requests
-     *
-     */
-    async function genqlClient(options: CliOptions = {}): Promise<T> {
-        //let req_headers: Record<string, string> = {}
-
-        const { anonymous, headers, ...rest } = options
-
-        if (!serviceUrl()) {
-            console.warn('requred param srv_url is undefined, please check EnvConfig object!')
-        }
-        //if (!anonymous) {
-        //req_headers = ((await setReqConfig()).headers ?? {}) as Record<string, string>
-        // setJwtExp(req_headers['Authorization'])
-        // }
-
-        return createClient({
-            url: `${serviceUrl()}${path}`,
-            headers: async () => ({
-                ...(options.anonymous ? {} : (((await setReqConfig()).headers ?? {}) as Record<string, string>)),
-                ...headers,
-            }),
-            batch: { batchInterval: 50, maxBatchSize: 100 },
-            ...rest,
-        })
-    }
-
-    async function genqlClientWs() {
-        if (/* accessTokenHasExpired() || */ !wsClient) {
-            //const req_headers = ((await setReqConfig()).headers ?? {}) as Record<string, string>
-
-            //setJwtExp(req_headers['Authorization'])
-
-            wsClient = createClient({
-                url: `${httpToWs(serviceUrl())}${path}`,
-                cache: 'reload',
-                batch: { batchInterval: 50, maxBatchSize: 100 },
-                subscription: {
-                    reconnect: true,
-                    reconnectionAttempts: 5,
-                    headers: async () => ((await setReqConfig()).headers ?? {}) as Record<string, string>,
-                },
-            })
-        }
-
-        return wsClient
-    }
-
-    return { getGenqlClient, /* resetGenqlClient, */ genqlClient, genqlClientWs }
-}
+import type { AxiosRequestConfig } from 'axios'
+import type { ClientOptions, createClient } from '@genql/runtime'
+import { httpToWs } from './Config'
+//import { parseJwt } from '../helpers/parseJwt'
+
+interface CliOptions extends Omit<ClientOptions, 'url'> {
+    anonymous?: boolean
+}
+
+export function generateGenqlClient<T extends ReturnType<typeof createClient>>({
+    setReqConfig,
+    createClient,
+    serviceUrl,
+    path = '/v1/graphql',
+}: {
+    // jwt_exp: number
+    setReqConfig: () => Promise<AxiosRequestConfig<any>>
+    createClient: (options?: ClientOptions | undefined) => T | null
+    serviceUrl: () => string
+    path?: string
+}) {
+    // let jwt_exp = 0
+
+    let client: T | null = null
+
+    let wsClient: T | null = null
+
+    //function accessTokenHasExpired() {
+    //    const nowTime = Math.floor(new Date().getTime() / 1000)
+    //
+    //    //set exp time -20sec for token to be refreshed early
+    //    return jwt_exp - 10 <= nowTime
+    //}
+
+    async function getGenqlClient() {
+        if (/* accessTokenHasExpired() || */ !client) {
+            client = await genqlClient()
+
+            return client
+        }
+
+        return client
+    }
+
+    //function resetGenqlClient() {
+    //    client = null
+    //}
+
+    // function setJwtExp(token?: string) {
+    //     if (!token) return
+    //
+    //     const parsed_jwt = parseJwt<{ exp: number }>(token)?.exp
+    //
+    //     jwt_exp = parsed_jwt || 0
+    // }
+
+    /**
+     *
+     * This is used for anonymous requests as well as authenticated requests
+     *
+     */
+    async function genqlClient(options: CliOptions = {}): Promise<T | null> {
+        let req_headers: Record<string, string> = {}
+
+        const { anonymous, headers, ...rest } = options
+
+        if (!serviceUrl()) {
+            console.warn('requred param srv_url is undefined, please check EnvConfig object!')
+        }
+        if (!anonymous) {
+            req_headers = ((await setReqConfig()).headers ?? {}) as Record<string, string>
+            if (!req_headers['Authorization']) return null
+        }
+
+        return createClient({
+            url: `${serviceUrl()}${path}`,
+            headers: async () => ({
+                ...req_headers,
+                ...headers,
+            }),
+            batch: { batchInterval: 50, maxBatchSize: 100 },
+            ...rest,
+        })
+    }
+
+    async function genqlClientWs() {
+        if (/* accessTokenHasExpired() || */ !wsClient) {
+            const req_headers = ((await setReqConfig()).headers ?? {}) as Record<string, string>
+
+            if (!req_headers['Authorization']) return null
+
+            //setJwtExp(req_headers['Authorization'])
+
+            wsClient = createClient({
+                url: `${httpToWs(serviceUrl())}${path}`,
+                cache: 'reload',
+                batch: { batchInterval: 50, maxBatchSize: 100 },
+                subscription: {
+                    reconnect: true,
+                    reconnectionAttempts: 5,
+                    headers: async () => req_headers,
+                },
+            })
+        }
+
+        return wsClient
+    }
+
+    return { getGenqlClient, /* resetGenqlClient, */ genqlClient, genqlClientWs }
+}

package/src/helpers/generateSrvAuthBindings.ts

@@ -1,204 +1,217 @@
-import axios, { AxiosResponse, ResponseType } from 'axios'
-import { EnvironmentEnums, parseJwt } from '..'
-
-export function generateSrvAuthBindings<FeatureEnums = never>(
-    SRV_AUTH: () => string,
-    DEVELOPMENT: () => boolean,
-    EnvironmentToOperateFn: () => string,
-    logout?: () => void,
-) {
-    if (window.__ASMA__SHELL__?.auth_bindings) {
-        return window.__ASMA__SHELL__.auth_bindings as typeof auth_bindings
-    }
-    let jwtToken = ''
-
-    let features: Set<FeatureEnums> | undefined
-
-    let parsed_jwt: any | undefined
-
-    let fetchJwtPromise: Promise<{
-        data: { message: string; token?: string; features?: FeatureEnums[]; errors: { message: string }[] }
-    }> | null = null
-
-    const isJwtInvalid = () => (jwtToken && accessTokenHasExpired()) || !jwtToken
-
-    const isJwtValid = () => !isJwtInvalid()
-
-    async function srvAuthGet<R>(url: string, headers?: Record<string, string>) {
-        if (DEVELOPMENT() && EnvironmentToOperateFn()) {
-            if (EnvironmentToOperateFn() in EnvironmentEnums) {
-                url = `${url}&env=${EnvironmentToOperateFn()}`
-
-                url = url.includes('&') && !url.includes('?') ? url.replace('&', '?') : url
-            } else {
-                console.warn(
-                    'EnvironmentToOperateFn() is not a valid EnvironmentEnums',
-                    'shall be one of:',
-                    EnvironmentEnums,
-                    'actual value:',
-                    EnvironmentToOperateFn(),
-                )
-            }
-        }
-
-        return axios.get<unknown, AxiosResponse<R>>(`${SRV_AUTH()}${url}`, {
-            headers: {
-                ...headers,
-                'asma-origin': window.location.origin,
-            },
-            withCredentials: true,
-        })
-    }
-
-    function accessTokenHasExpired(): boolean {
-        const tokenObj = getParsedJwt()
-
-        const accessTokenExpDate = tokenObj?.exp || 0
-
-        const nowTime = Math.floor(new Date().getTime() / 1000)
-
-        //set exp time -20sec for token to be refreshed early
-        return accessTokenExpDate - 10 <= nowTime
-    }
-
-    async function signin(url: string, headers?: Record<string, string>) {
-        const { data } = await srvAuthGet<{ token: string; features: FeatureEnums[] }>(url, headers)
-
-        setAuthData(data)
-
-        return data
-    }
-
-    async function signoutAuth() {
-        setAuthData({ token: '' })
-        await 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
-    }
-
-    function getJwtToken() {
-        return jwtToken
-    }
-
-    async function getJwtTokenAsync() {
-        if (isJwtInvalid()) {
-            const new_jwt = await getNewJwtToken()
-
-            return new_jwt
-        } else {
-            return jwtToken
-        }
-    }
-
-    async function setReqConfig<T = unknown>(data?: T, responseType?: ResponseType) {
-        const token = await getJwtTokenAsync()
-
-        const res = {
-            data: data,
-            responseType: responseType,
-            headers: {} as Record<string, string>,
-        }
-
-        if (token) {
-            res.headers['Authorization'] = `Bearer ${token}`
-        }
-
-        return res
-    }
-
-    async function getNewJwtToken() {
-        try {
-            if (!fetchJwtPromise) {
-                fetchJwtPromise = srvAuthGet('/token')
-            }
-
-            const { data } = await fetchJwtPromise
-
-            if (!data || data.errors || data.message != 'Success') {
-                logout?.() || signoutAuth()
-            }
-            if (!data.token) {
-                throw new Error('Token is not present in the result')
-            }
-            setAuthData({ token: data.token || '', features: data.features || [] })
-
-            fetchJwtPromise = null
-
-            return jwtToken
-        } catch (error) {
-            logout?.() || signoutAuth()
-            //signoutAuth()
-
-            fetchJwtPromise = null
-
-            console.error(error)
-
-            return jwtToken
-        }
-    }
-
-    function getParsedJwt<R = { user_id: string; exp: number }>(): R | undefined {
-        if (!parsed_jwt) {
-            parsed_jwt = parseJwt<R>(jwtToken)
-        }
-        return parsed_jwt
-    }
-    function getFeatures() {
-        return features
-    }
-    /**
-     *
-     * @param featureName feature_name_enums add this: generateSrvAuthBindings<feature_name_enums.>(...)
-     * @returns boolean
-     */
-    function hasFeature(featureName: FeatureEnums) {
-        return !!features?.has(featureName)
-    }
-
-    const auth_bindings = {
-        hasFeature,
-        getFeatures,
-        isJwtValid,
-        signin,
-        srvAuthGet,
-        signoutAuth,
-        setReqConfig,
-        getJwtTokenAsync,
-        getNewJwtToken,
-        getUserId,
-        getParsedJwt,
-        getJwtToken,
-        accessTokenHasExpired,
-    }
-    window.__ASMA__SHELL__ = window.__ASMA__SHELL__ || {}
-
-    window.__ASMA__SHELL__.auth_bindings = auth_bindings
-
-    return auth_bindings
-}
-/**
- * @deprecated use generateSrvAuthBindings
- * @param SRV_AUTH
- * @param DEVELOPMENT
- * @param ENVIRONMENT_TO_OPERATE
- * @param logout
- * @returns
- */
-export function generateSrvAuthBindingsMicroApp(
-    SRV_AUTH: () => string,
-    DEVELOPMENT: () => boolean,
-    ENVIRONMENT_TO_OPERATE: () => EnvironmentEnums,
-    logout?: () => void,
-) {
-    return (
-        window.__ASMA__SHELL__?.auth_bindings ||
-        generateSrvAuthBindings(SRV_AUTH, DEVELOPMENT, ENVIRONMENT_TO_OPERATE, logout)
-    )
-}
+import axios, {type  AxiosResponse, type ResponseType } from 'axios'
+import { EnvironmentEnums, parseJwt } from '..'
+
+let logoutsuccesfull = false
+
+export function generateSrvAuthBindings<FeatureEnums = never>(
+    SRV_AUTH: () => string,
+    DEVELOPMENT: () => boolean,
+    EnvironmentToOperateFn: () => string,
+    logout?: () => void,
+) {
+    let logoutMfes: (() => void)[] = []
+
+    if (logout && window.__ASMA__SHELL__?.auth_bindings) {
+        logoutMfes.push(logout)
+    }
+
+    if (window.__ASMA__SHELL__?.auth_bindings) {
+        window.__ASMA__SHELL__.logoutMfes = logoutMfes
+        return window.__ASMA__SHELL__.auth_bindings as typeof auth_bindings
+    }
+
+    let jwtToken = ''
+
+    let features: Set<FeatureEnums> | undefined
+
+    let parsed_jwt: any | undefined
+
+    let fetchJwtPromise: Promise<{
+        data: { message: string; token?: string; features?: FeatureEnums[]; errors: { message: string }[] }
+    }> | null = null
+
+    const isJwtInvalid = () => (jwtToken && accessTokenHasExpired()) || !jwtToken
+
+    const isJwtValid = () => !isJwtInvalid()
+
+    async function srvAuthGet<R>(url: string, headers?: Record<string, string>) {
+        if (DEVELOPMENT() && EnvironmentToOperateFn()) {
+            if (EnvironmentToOperateFn() in EnvironmentEnums) {
+                url = `${url}&env=${EnvironmentToOperateFn()}`
+
+                url = url.includes('&') && !url.includes('?') ? url.replace('&', '?') : url
+            } else {
+                console.warn(
+                    'EnvironmentToOperateFn() is not a valid EnvironmentEnums',
+                    'shall be one of:',
+                    EnvironmentEnums,
+                    'actual value:',
+                    EnvironmentToOperateFn(),
+                )
+            }
+        }
+
+        return axios.get<unknown, AxiosResponse<R>>(`${SRV_AUTH()}${url}`, {
+            headers: {
+                ...headers,
+                'asma-origin': window.location.origin,
+            },
+            withCredentials: true,
+        })
+    }
+
+    function accessTokenHasExpired(): boolean {
+        const tokenObj = getParsedJwt()
+
+        const accessTokenExpDate = tokenObj?.exp || 0
+
+        const nowTime = Math.floor(new Date().getTime() / 1000)
+
+        //set exp time -20sec for token to be refreshed early
+        return accessTokenExpDate - 10 <= nowTime
+    }
+
+    async function signin(url: string, headers?: Record<string, string>) {
+        const { data } = await srvAuthGet<{ token: string; features: FeatureEnums[] }>(url, headers)
+
+        setAuthData(data)
+
+        logoutsuccesfull = false
+
+        return data
+    }
+
+    async function signoutAuth() {
+        setAuthData({ token: '' })
+        await 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
+    }
+
+    function getJwtToken() {
+        return jwtToken
+    }
+
+    async function getJwtTokenAsync() {
+        if (isJwtInvalid()) {
+            const new_jwt = await getNewJwtToken()
+
+            return new_jwt
+        } else {
+            return jwtToken
+        }
+    }
+
+    async function setReqConfig<T = unknown>(data?: T, responseType?: ResponseType) {
+        const token = await getJwtTokenAsync()
+
+        const res = {
+            data: data,
+            responseType: responseType,
+            headers: {} as Record<string, string>,
+        }
+
+        if (token) {
+            res.headers['Authorization'] = `Bearer ${token}`
+        }
+
+        return res
+    }
+
+    async function getNewJwtToken() {
+        if(logoutsuccesfull) return
+        try {
+            if (!fetchJwtPromise) {
+                fetchJwtPromise = srvAuthGet('/token')
+            }
+
+            const { data } = await fetchJwtPromise
+
+            if (!data || data.errors || data.message != 'Success' || !data.token) {
+                logout?.()
+                logoutsuccesfull = true
+
+                //signoutAuth()
+            }
+
+            setAuthData({ token: data.token || '', features: data.features || [] })
+        } catch (error) {
+            logout?.()
+            logoutsuccesfull = true
+            //signoutAuth()
+
+            setAuthData({ token: '', features: [] })
+
+            console.error(error)
+        } finally {
+            fetchJwtPromise = null
+
+            return jwtToken
+        }
+    }
+
+    function getParsedJwt<R = { user_id: string; exp: number }>(): R | undefined {
+        if (!parsed_jwt) {
+            parsed_jwt = parseJwt<R>(jwtToken)
+        }
+        return parsed_jwt
+    }
+    function getFeatures() {
+        return features
+    }
+    /**
+     *
+     * @param featureName feature_name_enums add this: generateSrvAuthBindings<feature_name_enums.>(...)
+     * @returns boolean
+     */
+    function hasFeature(featureName: FeatureEnums) {
+        return !!features?.has(featureName)
+    }
+
+    const auth_bindings = {
+        hasFeature,
+        getFeatures,
+        isJwtValid,
+        signin,
+        srvAuthGet,
+        signoutAuth,
+        setReqConfig,
+        getJwtTokenAsync,
+        getNewJwtToken,
+        getUserId,
+        getParsedJwt,
+        getJwtToken,
+        accessTokenHasExpired,
+    }
+    window.__ASMA__SHELL__ = window.__ASMA__SHELL__ || {}
+
+    window.__ASMA__SHELL__.auth_bindings = auth_bindings
+
+    return auth_bindings
+}
+/**
+ * @deprecated use generateSrvAuthBindings
+ * @param SRV_AUTH
+ * @param DEVELOPMENT
+ * @param ENVIRONMENT_TO_OPERATE
+ * @param logout
+ * @returns
+ */
+export function generateSrvAuthBindingsMicroApp(
+    SRV_AUTH: () => string,
+    DEVELOPMENT: () => boolean,
+    ENVIRONMENT_TO_OPERATE: () => EnvironmentEnums,
+    logout?: () => void,
+) {
+    return (
+        window.__ASMA__SHELL__?.auth_bindings ||
+        generateSrvAuthBindings(SRV_AUTH, DEVELOPMENT, ENVIRONMENT_TO_OPERATE, logout)
+    )
+}