Implemented popup state management logic; Multiple other optmizations (error/state handling; type casting; refactor) and formatting;

Author: henser

src/index.ts

@@ -7,75 +7,77 @@ import {
     pollOauthSession,
     retrieveAccessToken,
     refreshToken,
-    revokeToken,
+    revokeToken
 } from './Oauth';
 
 const DOMAIN_WINDOW_DEFAULT_URL = 'https://dev.frontify.test/finder';
 const POPUP_DEFAULT_TITLE = 'Authorize Frontify';
 const POPUP_STATE = {
-    open: false,
-    retry: false
+    open: false
 }
 
 let popup: Popup;
 
 export async function authorize(
     configuration: AuthenticationConfig,
-    popupConfiguration?: PopupConfiguration,
-): Promise<Token | void | null>{
-    let token = null;
+    popupConfiguration?: PopupConfiguration
+): Promise<Token | void>{
 
     if (POPUP_STATE.open) {
-        console.log('popup is already open!');
-        return;
+        logMessage('warning', {
+            code: 'ERR_POPUP_OPEN',
+            message: 'Popup already open!'
+        })
+        throw new Error('Popup already open!');
     }
 
-    POPUP_STATE.open = true;
+    popup = createPopUp(
+        popupConfiguration ?? {
+            width: 800,
+            height: 600,
+            top: 50,
+            left: 50,
+            title: POPUP_DEFAULT_TITLE,
+        },
+    );
 
-    if (!POPUP_STATE.retry) {
-        popup = createPopUp(
-            popupConfiguration ?? {
-                width: 800,
-                height: 600,
-                top: 50,
-                left: 50,
-                title: POPUP_DEFAULT_TITLE,
-            },
-        );
-    }
+    POPUP_STATE.open = true;
 
     if (!configuration.domain) {
-        await openDomainPopUp(popup).then(() => {
-            configuration.domain = popup.getDomain();
-            POPUP_STATE.retry = false;
-            token = authenticate(configuration, popup).catch(() => {
-                delete(configuration.domain);
-                POPUP_STATE.retry = true;
-                authorize(configuration, popupConfiguration);
+        return openDomainPopUp(configuration, popup).then((res) => {
+            POPUP_STATE.open = false;
+            if (res) {
+                return res;
+            }
+        }).catch(() => {
+            delete(configuration.domain);
+            logMessage('error', {
+                code: 'ERR_AUTH_SKIPPED',
+                message: 'Domain not inserted!'
             });
+            throw new Error('Domain not inserted!');
         });
     } else {
-        POPUP_STATE.retry = false;
-        token = authenticate(configuration, popup).catch(() => {
-            delete(configuration.domain);
-            POPUP_STATE.retry = true;
-            authorize(configuration, popupConfiguration);
+        return authenticate(configuration, popup).then((res) => {
+            POPUP_STATE.open = false;
+            if (res) {
+                return res;
+            }
+        }).catch((error) => {
+            POPUP_STATE.open = false;
+            throw new Error(error);
         });
     }
-
-    return token;
-
 }
 
 async function authenticate(configuration: AuthenticationConfig, popUp: Popup): Promise<Token> {
     try {
         const { authorizationUrl, codeVerifier, sessionId } = await computeAuthorizationUrl(configuration);
-        await awaitUserAuthorization(authorizationUrl, popUp);
+        await openAuthPopUp(authorizationUrl, popUp);
         const authorizationCode = await pollOauthSession(configuration, sessionId);
         return retrieveAccessToken(configuration, authorizationCode, codeVerifier);
     } catch (error) {
-        const errorMessage = `Error generating session. Make sure the inserted domain ${configuration.domain} is a valid and secure Frontify instance`;
-        delete(configuration.domain);
+        const errorMessage = `Error generating session. Make sure that the inserted domain is a valid and secure Frontify instance.`;
         popUp.popUp?.postMessage({domainError: errorMessage}, '*');
         logMessage('error', {
             code: 'ERR_AUTH_FAILED',
@@ -86,20 +88,20 @@ async function authenticate(configuration: AuthenticationConfig, popUp: Popup):
 }
 
 export async function refresh(token: Token): Promise<Token> {
-    return await refreshToken(token.bearerToken.domain, token.bearerToken.refreshToken, token.clientId, token.scopes);
+    return refreshToken(token.bearerToken.domain, token.bearerToken.refreshToken, token.clientId, token.scopes);
 }
 
 export async function revoke(token: Token): Promise<Token> {
     await revokeToken(token.bearerToken.domain, token.bearerToken.accessToken)
     return token;
 }
 
-async function awaitUserAuthorization(authorizationUrl: string, popUp: Popup) {
-    popUp.navigateToUrl(authorizationUrl);
+function openDomainPopUp(configuration: AuthenticationConfig, popUp: Popup): Promise<Token> {
+    popUp.navigateToUrl(DOMAIN_WINDOW_DEFAULT_URL);
 
     logMessage('warning', {
-        code: 'WARN_AUTH_OPEN',
-        message: 'Auth window opened!'
+        code: 'WARN_DOMAIN_OPEN',
+        message: 'Popup window opened!'
     });
 
     return new Promise((resolve, reject) => {
@@ -108,43 +110,45 @@ async function awaitUserAuthorization(authorizationUrl: string, popUp: Popup) {
             popUp.close();
             reject();
             logMessage('error', {
-                code: 'WARN_AUTH_SUCCESS',
-                message: 'Auth timeout!'
+                code: 'ERR_DOMAIN_TIMEOUT',
+                message: 'Popup window timeout!'
             })
         }, 5 * 60 * 1000);
 
-        popUp.onSuccess(() => {
-            POPUP_STATE.open = false;
+        popUp.onDomain(() => {
             clearTimeout(timeout);
-            popUp.close();
-            resolve(null);
+            configuration.domain = popup.getDomain();
+            authenticate(configuration, popup).then((result) => {
+                resolve(result);
+            }).catch((error) => {
+                throw new Error(error ?? 'Could not verify instance!');
+            });
             logMessage('warning', {
-                code: 'WARN_AUTH_SUCCESS',
-                message: 'Auth success!'
+                code: 'WARN_DOMAIN_SELECT',
+                message: 'Domain input submitted!'
             })
         });
 
-        popUp.onCancelled(() => {
+        popUp.onAborted(() => {
             POPUP_STATE.open = false;
             clearTimeout(timeout);
             popUp.close();
             reject();
             logMessage('warning', {
-                code: 'WARN_AUTH_CANCELLED',
-                message: 'Auth cancelled!'
+                code: 'WARN_DOMAIN_CLOSED',
+                message: 'Popup window closed!'
             })
         });
     });
 }
 
-function openDomainPopUp(popUp: Popup): Promise<void> {
-    if (!POPUP_STATE.retry) {
-        popUp.navigateToUrl(DOMAIN_WINDOW_DEFAULT_URL);
-        logMessage('warning', {
-            code: 'WARN_DOMAIN_OPEN',
-            message: 'Domain window opened!'
-        });
-    }
+function openAuthPopUp(url: string, popUp: Popup): Promise<void> {
+    popUp.navigateToUrl(url);
+
+    logMessage('warning', {
+        code: 'WARN_DOMAIN_OPEN',
+        message: 'Popup window opened!'
+    });
 
     return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
@@ -153,27 +157,40 @@ function openDomainPopUp(popUp: Popup): Promise<void> {
             reject();
             logMessage('error', {
                 code: 'ERR_DOMAIN_TIMEOUT',
-                message: 'Domain window timeout!'
+                message: 'Popup window timeout!'
             })
         }, 5 * 60 * 1000);
 
-        popUp.onDomain(() => {
+        popUp.onAborted(() => {
+            POPUP_STATE.open = false;
             clearTimeout(timeout);
+            popUp.close();
+            reject();
+            logMessage('warning', {
+                code: 'WARN_DOMAIN_CLOSED',
+                message: 'Popup window closed!'
+            })
+        });
+
+        popUp.onSuccess(() => {
+            POPUP_STATE.open = false;
+            clearTimeout(timeout);
+            popUp.close();
             resolve();
             logMessage('warning', {
-                code: 'WARN_DOMAIN_SELECT',
-                message: 'Domain select success!'
+                code: 'WARN_AUTH_SUCCESS',
+                message: 'Auth success!'
             })
         });
 
-        popUp.onAborted(() => {
+        popUp.onCancelled(() => {
             POPUP_STATE.open = false;
             clearTimeout(timeout);
             popUp.close();
             reject();
             logMessage('warning', {
-                code: 'WARN_DOMAIN_CLOSED',
-                message: 'Domain window closed!'
+                code: 'WARN_AUTH_CANCELLED',
+                message: 'Auth cancelled!'
             })
         });
     });