agora-appbuilder-core 3.0.13 → 3.0.28-beta-9

package/template/src/auth/useIDPAuth.electron.tsx

@@ -0,0 +1,125 @@
+import {useContext} from 'react';
+import {
+  enableIDPAuth,
+  getIDPAuthLoginURL,
+  addEventListenerForToken,
+} from './openIDPURL.electron';
+import StorageContext from '../components/StorageContext';
+import useTokenAuth from './useTokenAuth';
+import {useHistory} from '../components/Router';
+import {useString} from '../utils/useString';
+import {authSessionTimeoutToastHeading} from '../language/default-labels/commonLabels';
+import getUniqueID from '../utils/getUniqueID';
+import {LogSource, logger} from '../logger/AppBuilderLogger';
+
+export const useIDPAuth = () => {
+  const {store, setStore} = useContext(StorageContext);
+  const {tokenLogout} = useTokenAuth();
+  const headingText = useString(authSessionTimeoutToastHeading)();
+  const history = useHistory();
+  const idpLogout = () => {
+    return new Promise((resolve, reject) => {
+      const requestId = getUniqueID();
+      const startReqTs = Date.now();
+      try {
+        logger.log(
+          LogSource.NetworkRest,
+          'idp_logout',
+          'API idp_logout Trying to get logout url',
+          {
+            requestId,
+            startReqTs,
+          },
+        );
+        //v1/idp/logout -> will generate and return URL for IDP logout(frontend need to call this)
+        fetch(`${$config.BACKEND_ENDPOINT}/v1/idp/logout`, {
+          headers: {
+            authorization: store?.token ? `Bearer ${store?.token}` : '',
+            'X-Request-Id': requestId,
+            'X-Session-Id': logger.getSessionId(),
+          },
+        })
+          .then(response => response.json())
+          .then((res: any) => {
+            if (res && res?.url) {
+              const endReqTs = Date.now();
+              const latency = endReqTs - startReqTs;
+              logger.log(
+                LogSource.NetworkRest,
+                'idp_logout',
+                'API idp_logout Got logout url',
+                {
+                  requestId,
+                  responseData: res,
+                  startReqTs,
+                  endReqTs,
+                  latency,
+                },
+              );
+              //Storing the URL in the local variable
+              const IDPAuthLogoutURL =
+                res?.url +
+                `&returnTo=${encodeURIComponent(getIDPAuthLoginURL())}`;
+              //manage backend logout
+              //it will invalid the user session from the manage backend
+              tokenLogout()
+                .then(() => {
+                  //call IDP logout url
+                  addEventListenerForToken(history, headingText);
+                  setTimeout(() => {
+                    window.open(IDPAuthLogoutURL, 'modal');
+                  });
+                  resolve(true);
+                })
+                .catch(() => {
+                  reject(false);
+                });
+            } else {
+              const endReqTs = Date.now();
+              logError(
+                {errorMessage: 'API idp_logout logurl is empty'},
+                requestId,
+                startReqTs,
+                endReqTs,
+              );
+              reject(false);
+            }
+          })
+          .catch(error => {
+            const endReqTs = Date.now();
+            logError(error, requestId, startReqTs, endReqTs);
+            reject(false);
+          });
+      } catch (error) {
+        const endReqTs = Date.now();
+        logError(error, requestId, startReqTs, endReqTs);
+        reject(false);
+      }
+    });
+  };
+
+  const logError = (
+    error: any,
+    requestId: string,
+    startReqTs: number,
+    endReqTs: number,
+  ) => {
+    const latency = endReqTs - startReqTs;
+    logger.error(
+      LogSource.NetworkRest,
+      'idp_logout',
+      'Error on calling API idp_logout',
+      error,
+      {
+        requestId,
+        startReqTs,
+        endReqTs,
+        latency,
+      },
+    );
+  };
+  return {
+    enableIDPAuth,
+    idpLogout,
+  };
+};

package/template/src/auth/useIDPAuth.native.tsx

@@ -0,0 +1,130 @@
+import {useContext} from 'react';
+import {Linking} from 'react-native';
+import InAppBrowser from 'react-native-inappbrowser-reborn';
+import {
+  enableIDPAuth,
+  getDeepLinkURI,
+  getIDPAuthLoginURL,
+} from './openIDPURL.native';
+import StorageContext from '../components/StorageContext';
+import useTokenAuth from './useTokenAuth';
+import getUniqueID from '../utils/getUniqueID';
+import {LogSource, logger} from '../logger/AppBuilderLogger';
+
+export const useIDPAuth = () => {
+  const {store, setStore} = useContext(StorageContext);
+  const {tokenLogout} = useTokenAuth();
+  const idpLogout = (setShowNativePopup: (val: boolean) => void) => {
+    return new Promise((resolve, reject) => {
+      const requestId = getUniqueID();
+      const startReqTs = Date.now();
+      try {
+        logger.log(
+          LogSource.NetworkRest,
+          'idp_logout',
+          'API idp_logout Trying to get logout url',
+          {
+            requestId,
+            startReqTs,
+          },
+        );
+        //v1/idp/logout -> will generate and return URL for IDP logout(frontend need to call this)
+        fetch(`${$config.BACKEND_ENDPOINT}/v1/idp/logout`, {
+          headers: {
+            authorization: store?.token ? `Bearer ${store?.token}` : '',
+            'X-Request-Id': requestId,
+            'X-Session-Id': logger.getSessionId(),
+          },
+        })
+          .then(response => response.json())
+          .then((res: any) => {
+            if (res && res?.url) {
+              const endReqTs = Date.now();
+              const latency = endReqTs - startReqTs;
+              logger.log(
+                LogSource.NetworkRest,
+                'idp_logout',
+                'API idp_logout Got logout url',
+                {
+                  requestId: requestId,
+                  responseData: res,
+                  startReqTs,
+                  endReqTs,
+                  latency,
+                },
+              );
+              //Storing the URL in the local variable
+              const IDPAuthLogoutURL =
+                res?.url +
+                `&returnTo=${encodeURIComponent(getIDPAuthLoginURL())}`;
+              //manage backend logout
+              //it will invalid the user session from the manage backend
+              tokenLogout()
+                .then(() => {
+                  //call IDP logout url
+                  if (InAppBrowser.isAvailable()) {
+                    InAppBrowser.openAuth(
+                      IDPAuthLogoutURL,
+                      encodeURIComponent(getIDPAuthLoginURL()),
+                    ).then(res => {
+                      if (res && res?.type === 'cancel') {
+                        setShowNativePopup && setShowNativePopup(true);
+                      }
+                    });
+                  } else {
+                    Linking.openURL(IDPAuthLogoutURL);
+                  }
+                  resolve(true);
+                })
+                .catch(() => {
+                  reject(false);
+                });
+            } else {
+              const endReqTs = Date.now();
+              logError(
+                {errorMessage: 'API idp_logout logurl is empty'},
+                requestId,
+                startReqTs,
+                endReqTs,
+              );
+              reject(false);
+            }
+          })
+          .catch(error => {
+            const endReqTs = Date.now();
+            logError(error, requestId, startReqTs, endReqTs);
+            reject(false);
+          });
+      } catch (error) {
+        const endReqTs = Date.now();
+        logError(error, requestId, startReqTs, endReqTs);
+        reject(false);
+      }
+    });
+  };
+
+  const logError = (
+    error: any,
+    requestId: string,
+    startReqTs: number,
+    endReqTs: number,
+  ) => {
+    const latency = endReqTs - startReqTs;
+    logger.error(
+      LogSource.NetworkRest,
+      'idp_logout',
+      'Error on calling API idp_logout',
+      error,
+      {
+        requestId,
+        startReqTs,
+        endReqTs,
+        latency,
+      },
+    );
+  };
+  return {
+    enableIDPAuth,
+    idpLogout,
+  };
+};

package/template/src/auth/useIDPAuth.tsx

@@ -0,0 +1,124 @@
+import {Linking} from 'react-native';
+import {useLocation} from '../components/Router';
+import {enableIDPAuth, getIDPAuthLoginURL} from './openIDPURL';
+import useTokenAuth from './useTokenAuth';
+import StorageContext from '../components/StorageContext';
+import {useContext} from 'react';
+import getUniqueID from '../utils/getUniqueID';
+import {LogSource, logger} from '../logger/AppBuilderLogger';
+
+export const useIDPAuth = () => {
+  const location = useLocation();
+  const {store, setStore} = useContext(StorageContext);
+  const {tokenLogout} = useTokenAuth();
+  const idpLogout = (dummy: any) => {
+    return new Promise((resolve, reject) => {
+      const requestId = getUniqueID();
+      const startReqTs = Date.now();
+      try {
+        logger.log(
+          LogSource.NetworkRest,
+          'idp_logout',
+          'API idp_logout Trying to get logout url',
+          {
+            requestId,
+            startReqTs,
+          },
+        );
+        //v1/idp/logout -> will generate and return URL for IDP logout(frontend need to call this)
+        fetch(`${$config.BACKEND_ENDPOINT}/v1/idp/logout`, {
+          credentials: 'include',
+          headers: {
+            authorization: store?.token ? `Bearer ${store?.token}` : '',
+            'X-Request-Id': requestId,
+            'X-Session-Id': logger.getSessionId(),
+          },
+        })
+          .then(response => response.json())
+          .then((res: any) => {
+            if (res && res?.url) {
+              const endReqTs = Date.now();
+              const latency = endReqTs - startReqTs;
+              logger.log(
+                LogSource.NetworkRest,
+                'idp_logout',
+                'API idp_logout Got logout url',
+                {
+                  requestId: requestId,
+                  responseData: res,
+                  startReqTs,
+                  endReqTs,
+                  latency,
+                },
+              );
+              //Storing the URL in the local variable
+              // const IDPAuthLogoutURL =
+              //   res?.url + `&returnTo=${window.location.origin}`;
+              const IDPAuthLogoutURL =
+                res?.url +
+                `&returnTo=${encodeURIComponent(
+                  getIDPAuthLoginURL(location.pathname),
+                )}`;
+              //manage backend logout
+              //it will invalid the user session from the manage backend
+              //cookie logout -> true
+              //regular logout -> false
+              tokenLogout(false)
+                .then(() => {
+                  //open idp logout url
+                  Linking.openURL(IDPAuthLogoutURL);
+                  resolve(true);
+                })
+                .catch(() => {
+                  reject(false);
+                });
+            } else {
+              const endReqTs = Date.now();
+              logError(
+                {errorMessage: 'API idp_logout logurl is empty'},
+                requestId,
+                startReqTs,
+                endReqTs,
+              );
+              reject(false);
+            }
+          })
+          .catch(error => {
+            const endReqTs = Date.now();
+            logError(error, requestId, startReqTs, endReqTs);
+            reject(false);
+          });
+      } catch (error) {
+        const endReqTs = Date.now();
+        logError(error, requestId, startReqTs, endReqTs);
+        reject(false);
+      }
+    });
+  };
+
+  const logError = (
+    error: any,
+    requestId: string,
+    startReqTs: number,
+    endReqTs: number,
+  ) => {
+    const latency = endReqTs - startReqTs;
+    logger.error(
+      LogSource.NetworkRest,
+      'idp_logout',
+      'Error on calling API idp_logout',
+      error,
+      {
+        requestId,
+        startReqTs,
+        endReqTs,
+        latency,
+      },
+    );
+  };
+
+  return {
+    enableIDPAuth,
+    idpLogout,
+  };
+};

package/template/src/auth/useTokenAuth.tsx

@@ -0,0 +1,267 @@
+import React, {useEffect, useContext, useRef} from 'react';
+import jwt_decode from 'jwt-decode';
+import StorageContext from '../components/StorageContext';
+import SdkEvents from '../utils/SdkEvents';
+import isSDK from '../utils/isSDK';
+import {getPlatformId} from './config';
+import {LogSource, logger} from '../logger/AppBuilderLogger';
+import getUniqueID from '../utils/getUniqueID';
+const REFRESH_TOKEN_DURATION_IN_SEC = 59;
+
+const useTokenAuth = () => {
+  const tokenRef = useRef(null);
+  const {setStore, store} = useContext(StorageContext);
+  const [tokenExpiresAt, setTokenExpiresAt] = React.useState(0);
+  const timerRef = useRef(null);
+  const updateToken = (token: string) => {
+    setStore && setStore(store => ({...store, token}));
+  };
+
+  const validateToken = (token: string) => {
+    if (token && token.trim() !== '') {
+      const decoded = jwt_decode(token);
+      // @ts-ignore
+      const expiresAt = decoded?.exp * 1000;
+      if (Date.now() >= expiresAt) {
+        if (isSDK()) {
+          SdkEvents.emit('did-token-expire');
+        }
+        throw 'Token expired. Pass a new token';
+      }
+    } else {
+      if (isSDK()) {
+        SdkEvents.emit('token-not-found');
+      }
+      throw 'Token is missing in the options';
+    }
+    return true;
+  };
+
+  const getRefreshToken = async () => {
+    if (store?.token) {
+      const requestId = getUniqueID();
+      const startReqTs = Date.now();
+      logger.log(
+        LogSource.NetworkRest,
+        'token_refresh',
+        'API token_refresh Trying to refresh the token',
+        {
+          requestId: requestId,
+          startReqTs,
+        },
+      );
+      await fetch(`${$config.BACKEND_ENDPOINT}/v1/token/refresh`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          authorization: store?.token ? `Bearer ${store.token}` : '',
+          'X-Platform-ID': getPlatformId(),
+          'X-Request-Id': requestId,
+          'X-Session-Id': logger.getSessionId(),
+        },
+      })
+        .then(response => response.json())
+        .then(data => {
+          const endReqTs = Date.now();
+          const latency = endReqTs - startReqTs;
+          logger.log(
+            LogSource.NetworkRest,
+            'token_refresh',
+            'API token_refresh successfully done',
+            {
+              requestId,
+              responseData: data,
+              startReqTs,
+              endReqTs,
+              latency,
+            },
+          );
+          if (data?.token) {
+            updateToken(data.token);
+            if (isSDK()) {
+              SdkEvents.emit('token-refreshed');
+            }
+          }
+        });
+    } else {
+      //'debugging no token to refresh'
+    }
+  };
+
+  useEffect(() => {
+    if (!tokenExpiresAt) return;
+
+    timerRef.current = setInterval(() => {
+      const diffInSeconds = Math.floor(
+        Math.abs(tokenExpiresAt - Date.now()) / 1000,
+      );
+      // const minutesLeft = Math.floor(diffInSeconds / 60) % 60;
+      // const secondsLeft = (diffInSeconds - minutes * 60) % 60;
+
+      if (diffInSeconds < REFRESH_TOKEN_DURATION_IN_SEC) {
+        try {
+          if (isSDK()) {
+            SdkEvents.emit('will-token-expire');
+          }
+          getRefreshToken();
+          clearInterval(timerRef.current);
+        } catch (error) {
+          clearInterval(timerRef.current);
+        }
+      }
+      if (diffInSeconds < 0) {
+        clearInterval(timerRef.current);
+      }
+    }, 1000);
+
+    return () => {
+      clearInterval(timerRef.current);
+    };
+  }, [tokenExpiresAt]);
+
+  useEffect(() => {
+    const syncToken = async () => {
+      if (!store?.token) {
+        try {
+          timerRef.current && clearInterval(timerRef.current);
+        } catch (error) {
+          logger.debug(
+            LogSource.Internals,
+            'AUTH',
+            'error on clearing interval',
+            error,
+          );
+        }
+      } else {
+        const decoded = jwt_decode(store.token);
+        // @ts-ignore
+        const expiresAt = decoded?.exp * 1000;
+        if (Date.now() >= expiresAt) {
+          if (isSDK()) {
+            SdkEvents.emit('did-token-expire');
+          }
+          //token expired
+        } else {
+          setTokenExpiresAt(expiresAt);
+        }
+      }
+    };
+    tokenRef.current = store.token;
+    syncToken();
+  }, [store?.token]);
+
+  const enableTokenAuth = async (tokenparam?: string) => {
+    return new Promise(async (resolve, reject) => {
+      let token = '';
+      let updateTokenInStore = false;
+      try {
+        if (tokenparam) {
+          token = tokenparam;
+          updateTokenInStore = true;
+        } else {
+          token = store?.token;
+        }
+        if (token) {
+          try {
+            if (validateToken(token)) {
+              if (updateTokenInStore) {
+                updateToken(token);
+              }
+              setTimeout(() => {
+                resolve(true);
+              });
+            } else {
+              if (isSDK()) {
+                SdkEvents.emit('did-token-expire');
+              }
+            }
+          } catch (e) {
+            reject('Token expired');
+          }
+        } else {
+          if (isSDK()) {
+            SdkEvents.emit('token-not-found');
+          }
+          reject('Token not found');
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+
+  const tokenLogout = async (cookieLogout: boolean = false) => {
+    return new Promise((resolve, reject) => {
+      try {
+        const startReqTs = Date.now();
+        const requestId = getUniqueID();
+        logger.log(
+          LogSource.NetworkRest,
+          'idp_logout',
+          'Trying to call v1 logout',
+          {
+            startReqTs,
+            ...(cookieLogout ? {} : {requestId}),
+          },
+        );
+        fetch(
+          `${$config.BACKEND_ENDPOINT}/v1/logout`,
+          cookieLogout
+            ? {credentials: 'include'}
+            : {
+                headers: {
+                  authorization: tokenRef.current
+                    ? `Bearer ${tokenRef.current}`
+                    : '',
+                  'X-Request-Id': requestId,
+                  'X-Session-Id': logger.getSessionId(),
+                },
+              },
+        )
+          .then(response => response.text())
+          .then(res => {
+            const endReqTs = Date.now();
+            logger.log(
+              LogSource.NetworkRest,
+              'idp_logout',
+              'API V1 logout called successfully',
+              {
+                responseData: res,
+                startReqTs,
+                endReqTs,
+                latency: endReqTs - startReqTs,
+                ...(cookieLogout ? {} : {requestId}),
+              },
+            );
+            resolve(true);
+            updateToken(null);
+          })
+          .catch(error => {
+            const endReqTs = Date.now();
+            logger.error(
+              LogSource.NetworkRest,
+              'idp_logout',
+              'Error API V1 logout called successfully',
+              error,
+              {
+                startReqTs,
+                endReqTs,
+                latency: endReqTs - startReqTs,
+                ...(cookieLogout ? {} : {requestId}),
+              },
+            );
+            reject(false);
+          });
+      } catch (error) {
+        reject(false);
+      }
+    });
+  };
+
+  return {
+    enableTokenAuth,
+    tokenLogout,
+  };
+};
+
+export default useTokenAuth;