authscape 1.0.760 → 1.0.763

package/src/services/apiService.js

@@ -3,11 +3,22 @@ import querystring from 'query-string';
 import fileDownload from 'js-file-download';
 import Cookies from 'js-cookie';
 
-const setupDefaultOptions = async (ctx = null) => {
+// Cookie utility function
+const setCookie = (name, value, options = {}) => {
+  return new Promise((resolve) => {
+    let cookieString = `${name}=${value};`;
+    if (options.maxAge) cookieString += `max-age=${options.maxAge};`;
+    if (options.path) cookieString += `path=${options.path};`;
+    if (options.domain) cookieString += `domain=${options.domain};`;
+    if (options.secure) cookieString += `secure;`;
+    document.cookie = cookieString;
+    resolve();
+  });
+};
 
+const setupDefaultOptions = async (ctx = null) => {
     let defaultOptions = {};
-    if (ctx == null)
-    {
+    if (ctx == null) {
         let accessToken = Cookies.get('access_token') || '';
 
         if (accessToken !== null && accessToken !== undefined && accessToken != "") {
@@ -16,19 +27,14 @@ const setupDefaultOptions = async (ctx = null) => {
                     Authorization: "Bearer " + accessToken
                 }
             };
-        }
-        else {
+        } else {
             defaultOptions = {
-                headers: {
-                },
+                headers: {},
             };
         }
-    }
-    else
-    {
+    } else {
         defaultOptions = {
-            headers: {
-            },
+            headers: {},
         };
     }
 
@@ -36,7 +42,6 @@ const setupDefaultOptions = async (ctx = null) => {
 }
 
 const RefreshToken = async (originalRequest, instance) => {
-
     let accessToken = Cookies.get('access_token') || '';
     let refreshToken = Cookies.get('refresh_token') || '';
 
@@ -53,69 +58,36 @@ const RefreshToken = async (originalRequest, instance) => {
         }
     });
 
-    if (response != null && response.status == 200)
-    {
+    if (response != null && response.status == 200) {
         let domainHost = window.location.hostname.split('.').slice(-2).join('.');
         originalRequest.headers['Authorization'] = 'Bearer ' + response.data.access_token;
 
-
-
-
-
         await setCookie('access_token', response.data.access_token, {
-            maxAge: 60 * 60 * 24 * 365, // 1 year,
+            maxAge: 60 * 60 * 24 * 365,
             path: '/',
             domain: domainHost,
             secure: true
         });
 
         await setCookie('expires_in', response.data.expires_in, {
-            maxAge: 60 * 60 * 24 * 365, // 1 year,
+            maxAge: 60 * 60 * 24 * 365,
             path: '/',
             domain: domainHost,
             secure: true
         });
 
         await setCookie('refresh_token', response.data.refresh_token, {
-            maxAge: 60 * 60 * 24 * 365, // 1 year,
+            maxAge: 60 * 60 * 24 * 365,
             path: '/',
             domain: domainHost,
             secure: true
         });
-
-
-
-        // await setCookie(null, "access_token", response.data.access_token,
-        // {
-        //     maxAge: 2147483647,
-        //     path: '/',
-        //     domain: domainHost,
-        //     secure: true
-        // });
-    
-        // await setCookie(null, "expires_in", response.data.expires_in,
-        // {
-        //     maxAge: 2147483647,
-        //     path: '/',
-        //     domain: domainHost,
-        //     secure: true
-        // });
-    
-        // await setCookie(null, "refresh_token", response.data.refresh_token,
-        // {
-        //     maxAge: 2147483647,
-        //     path: '/',
-        //     domain: domainHost,
-        //     secure: true
-        // });
     }
 }
 
 export const apiService = (ctx = null) => {
-
     let env = process.env.stage;
-    if (env == "development")
-    {
+    if (env == "development") {
         process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
     }
 
@@ -123,185 +95,113 @@ export const apiService = (ctx = null) => {
 
     const instance = axios.create({
         baseURL: baseUri,
-        //timeout: 10000,
-        params: {} // do not remove this, its added to add params later in the config
+        params: {}
     });
 
     instance.interceptors.response.use(
         (response) => {
-        
-        return response;
+            return response;
         },
         async (error) => {
             const originalConfig = error.config;
             if (error.response) {
-
                 if (error.response.status === 401 && !originalConfig._retry) {
                     originalConfig._retry = true;
-
-                    // Do something, call refreshToken() request for example;
                     await RefreshToken(originalConfig, instance);
-
-                    // return a request
                     return instance.request(originalConfig);
                 }
 
                 if (error.response.status === 400) {
-                    // Do something 
-
-                    if (error.response.config.url.includes("/connect/token")) // remove the access and refresh if invalid
-                    {
+                    if (error.response.config.url.includes("/connect/token")) {
                         let domainHost = window.location.hostname.split('.').slice(-2).join('.');
-
-
                         Cookies.remove('access_token', { path: '/', domain: domainHost });
                         Cookies.remove('refresh_token', { path: '/', domain: domainHost });
                         Cookies.remove('expires_in', { path: '/', domain: domainHost });
-
-                        // destroyCookie(null, "access_token", {
-                        //     maxAge: 2147483647,
-                        //     path: '/',
-                        //     domain: domainHost
-                        // });
-
-                        // destroyCookie(null, "refresh_token", {
-                        //     maxAge: 2147483647,
-                        //     path: '/',
-                        //     domain: domainHost
-                        // });
-
-                        // destroyCookie(null, "expires_in", {
-                        //     maxAge: 2147483647,
-                        //     path: '/',
-                        //     domain: domainHost
-                        // });
                     }
-
                     return Promise.reject(error);
                 }
             }
-        
             return Promise.reject(error);
         }
     );
 
     return {
-
-        get: async (url, options= {}) => {
-            
-            try
-            {
+        get: async (url, options = {}) => {
+            try {
                 let defaultOptions = await setupDefaultOptions(ctx);
                 return await instance.get(url, { ...defaultOptions, ...options });
-            }
-            catch(error)
-            {
+            } catch (error) {
                 return error.response;
             }
         },
         post: async (url, data, options = {}) => {
-
-            try
-            {
+            try {
                 let defaultOptions = await setupDefaultOptions(ctx);
                 return await instance.post(url, data, { ...defaultOptions, ...options });
-            }
-            catch(error)
-            {
+            } catch (error) {
                 return error.response;
             }
         },
         put: async (url, data, options = {}) => {
-
-            try
-            {
+            try {
                 let defaultOptions = await setupDefaultOptions(ctx);
                 return await instance.put(url, data, { ...defaultOptions, ...options });
-            }
-            catch(error)
-            {
+            } catch (error) {
                 return error.response;
             }
         },
         delete: async (url, options = {}) => {
-
-            try
-            {
+            try {
                 let defaultOptions = await setupDefaultOptions(ctx);
                 return await instance.delete(url, { ...defaultOptions, ...options });
-            }
-            catch(error)
-            {
+            } catch (error) {
                 return error.response;
             }
         },
         GetCurrentUser: async () => {
-
-            try
-            {
+            try {
                 let accessToken = Cookies.get('access_token') || null;
 
-                if (accessToken)
-                {
+                if (accessToken) {
                     let defaultOptions = await setupDefaultOptions(null);
                     const response = await instance.get('/UserManagement', defaultOptions);
-                    if (response != null && response.status == 200)
-                    {
+                    if (response != null && response.status == 200) {
                         return response.data;
                     }
-                    // else if (response != null && response.status == 401)
-                    // {
-                    //     // call the login window maybe?
-                    // }
                 }
-
-            } catch(exp) {
-                //return -1;
-                console.log(exp.message);
+            } catch (exp) {
+                // Token invalid or expired
             }
-            return null;    
+            return null;
         },
-        DownloadFile : async (url, fileName, completed, method = "get", data = {}, mimeType = "application/octet-stream", passData = false) => {
-
-            try
-            {
-                //let defaultOptions = await setupDefaultOptions();
+        DownloadFile: async (url, fileName, completed, method = "get", data = {}, mimeType = "application/octet-stream", passData = false) => {
+            try {
                 let defaultOptions = {};
                 let options = { responseType: "blob" };
 
                 let response = null;
-                if (method == "get")
-                {
+                if (method == "get") {
                     response = await instance.get(url, { ...defaultOptions, ...options });
-                }
-                else if (method == "post")
-                {
+                } else if (method == "post") {
                     response = await instance.post(url, data, { ...defaultOptions, ...options });
                 }
-                
-                if (response != null && response.status === 200) {
 
-                    if (!passData)
-                    {
+                if (response != null && response.status === 200) {
+                    if (!passData) {
                         fileDownload(response.data, fileName, mimeType);
                         if (completed !== undefined) {
                             completed();
                         }
-                    }
-                    else
-                    {
+                    } else {
                         completed(response.data);
                     }
                 }
-            }
-            catch(error)
-            {
+            } catch (error) {
                 console.error(error);
                 if (completed !== undefined) {
                     completed();
                 }
             }
-
         }
     }
-}
+}

package/src/services/authService.js

@@ -75,16 +75,27 @@ export const authService = () => {
             let verifier = authService().generateRandomString();
             var challenge = await authService().challenge_from_verifier(verifier);
 
+            console.log('[PKCE] Login initiated');
+            console.log('[PKCE] Verifier generated | length:', verifier.length, '| preview:', verifier.substring(0, 10) + '...');
+            console.log('[PKCE] Challenge generated | value:', challenge);
+            console.log('[PKCE] authorityUri:', process.env.authorityUri);
+            console.log('[PKCE] client_id:', process.env.client_id);
+
             window.localStorage.setItem("verifier", verifier);
 
+            const storedVerifier = window.localStorage.getItem("verifier");
+            console.log('[PKCE] Verifier stored successfully:', storedVerifier === verifier);
+            console.log('[PKCE] Stored verifier length:', storedVerifier?.length);
+
             let redirectUri = window.location.origin + "/signin-oidc";
             let loginUri = process.env.authorityUri + "/connect/authorize?response_type=code&state=" + state + "&client_id=" + process.env.client_id + "&scope=email%20openid%20offline_access%20profile%20api1&redirect_uri=" + redirectUri + "&code_challenge=" + challenge + "&code_challenge_method=S256";
-            
+
             if (deviceId)
             {
                 loginUri += "&deviceId=" + deviceId; // will be for chrome extention and mobile apps later
             }
-            
+
+            console.log('[PKCE] Redirecting to:', loginUri);
             window.location.href = loginUri;
         },
         signUp: (redirectUrl = null) => {

package/src/services/signInValidator.js

@@ -4,24 +4,52 @@ import querystring from "query-string";
 // import Cookies from 'js-cookie';
 
 export const signInValidator = async (queryCode) => {
- 
+
   let codeVerifier = window.localStorage.getItem("verifier");
+
+      console.log('[PKCE] signInValidator called');
+      console.log('[PKCE] queryCode present:', !!queryCode, '| value:', queryCode);
+      console.log('[PKCE] codeVerifier present:', !!codeVerifier, '| length:', codeVerifier?.length);
+
       if (queryCode != null && codeVerifier != null)
       {
         const headers = {'Content-Type': 'application/x-www-form-urlencoded'}
 
-        let queryString = querystring.stringify({
+        const tokenParams = {
           code: queryCode,
           grant_type: "authorization_code",
           redirect_uri: window.location.origin + "/signin-oidc",
           client_id: process.env.client_id,
           client_secret: process.env.client_secret,
           code_verifier: codeVerifier
-        });
+        };
 
-        let response = await axios.post(process.env.authorityUri + '/connect/token', queryString, {
-          headers: headers
+        console.log('[PKCE] Token request params:', {
+          ...tokenParams,
+          client_secret: tokenParams.client_secret ? '***' : '(missing!)',
+          code: tokenParams.code?.substring(0, 10) + '...',
+          code_verifier: tokenParams.code_verifier?.substring(0, 10) + '... (length: ' + tokenParams.code_verifier?.length + ')',
         });
+        console.log('[PKCE] Token endpoint:', process.env.authorityUri + '/connect/token');
+        console.log('[PKCE] redirect_uri:', tokenParams.redirect_uri);
+
+        let queryString = querystring.stringify(tokenParams);
+
+        let response;
+        try {
+          response = await axios.post(process.env.authorityUri + '/connect/token', queryString, {
+            headers: headers
+          });
+          console.log('[PKCE] Token response status:', response.status);
+          console.log('[PKCE] Token response has access_token:', !!response.data?.access_token);
+          console.log('[PKCE] Token response has refresh_token:', !!response.data?.refresh_token);
+        } catch (err) {
+          console.error('[PKCE] Token request FAILED');
+          console.error('[PKCE] Status:', err.response?.status);
+          console.error('[PKCE] Error data:', JSON.stringify(err.response?.data));
+          console.error('[PKCE] Error message:', err.message);
+          throw err;
+        }
 
         let domainHost = window.location.hostname.split('.').slice(-2).join('.');
         window.localStorage.removeItem("verifier");