propro-utils 1.4.18 → 1.4.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "propro-utils",
-  "version": "1.4.18",
+  "version": "1.4.20",
   "description": "Auth middleware for propro-auth",
   "main": "src/index.js",
   "scripts": {

package/src/server/index.js

@@ -107,6 +107,7 @@ function proproAuthMiddleware(options = {}, userSchema) {
                     return res.status(400).send('No code received');
                 }
 
+                console.log('code', code);
                 const {tokens, account, redirectUrl} = await exchangeToken(
                     authUrl,
                     code,
@@ -150,16 +151,7 @@ function proproAuthMiddleware(options = {}, userSchema) {
 
                 console.log('redirectUrl', redirectUrl);
 
-                let urlToRedirect;
-
-                if (!redirectUrl.startsWith('http://') && !redirectUrl.startsWith('https://')) {
-                    if (redirectUrl.includes('localhost')) {
-                        urlToRedirect = `http://${redirectUrl}`;
-                    } else {
-                        urlToRedirect = `https://${redirectUrl}`;
-                    }
-                }
-
+                const urlToRedirect = formatRedirectUrl(clientUrl);
 
                 console.log('urlToRedirect', urlToRedirect);
 
@@ -184,15 +176,31 @@ function proproAuthMiddleware(options = {}, userSchema) {
 function constructRedirectUrl(clientUrl, appName, clientId, redirectUri) {
     console.log('constructRedirectUrl', clientUrl, appName, clientId, redirectUri);
 
-    if (!clientUrl.startsWith('http://') && !clientUrl.startsWith('https://')) {
-        if (clientUrl.includes('localhost')) {
-            clientUrl = `http://${clientUrl}`;
+    const urlToRedirect = formatRedirectUrl(clientUrl)
+
+    return `${urlToRedirect}/signin?response_type=code&appName=${appName}&client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}`;
+}
+
+/**
+ * Formats the redirect URL by adding 'http://' or 'https://' if necessary.
+ *
+ * @param {string} redirectUrl - The URL to be redirected.
+ * @return {string} The formatted redirect URL.
+ */
+function formatRedirectUrl(redirectUrl) {
+    let urlToRedirect;
+
+    if (!redirectUrl.startsWith('http://') && !redirectUrl.startsWith('https://')) {
+        if (redirectUrl.includes('localhost')) {
+            urlToRedirect = `http://${redirectUrl}`;
         } else {
-            clientUrl = `https://${clientUrl}`;
+            urlToRedirect = `https://${redirectUrl}`;
         }
+    } else {
+        urlToRedirect = redirectUrl;
     }
 
-    return `${clientUrl}/signin?response_type=code&appName=${appName}&client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}`;
+    return urlToRedirect;
 }
 
 

package/src/server/middleware/verifyToken.js

@@ -8,28 +8,28 @@ const tokenCache = new Map();
  * @param {string} secret - The secret used to sign the JWT.
  * @returns {object|null} - The decoded payload of the JWT if it is valid, or null if it is not valid.
  */
-async function verifyJWT(token, secret= "thisisasamplesecret") {
-  try {
-    return jwt.verify(token, secret);
-  } catch (err) {
-    if (err.name === 'TokenExpiredError') {
-      const newTokenData = await callTokenEndpoint(token);
-      return newTokenData ? jwt.verify(newTokenData, secret) : null;
+async function verifyJWT(token, secret = "thisisasamplesecret") {
+    try {
+        return jwt.verify(token, secret);
+    } catch (err) {
+        if (err.name === 'TokenExpiredError') {
+            const newTokenData = await callTokenEndpoint(token);
+            return newTokenData ? jwt.verify(newTokenData, secret) : null;
+        }
+        return null;
     }
-    return null;
-  }
 }
 
 async function callTokenEndpoint(token) {
-  try {
-    const response = await axios.post(`${process.env.AUTH_URL}/api/v1/tokens`, {
-      refreshToken: token,
-    });
-    return response.data.tokens ? response.data.tokens.access.token : null;
-  } catch (error) {
-    console.error('Error during token refresh:', error);
-    return null;
-  }
+    try {
+        const response = await axios.post(`${process.env.AUTH_URL}/api/v1/tokens`, {
+            refreshToken: token,
+        });
+        return response.data.tokens ? response.data.tokens.access.token : null;
+    } catch (error) {
+        console.error('Error during token refresh:', error);
+        return null;
+    }
 }
 
 /**
@@ -42,27 +42,32 @@ async function callTokenEndpoint(token) {
  * @returns {Promise<Object>} - The response data containing the access token.
  */
 async function exchangeToken(
-  authUrl,
-  code,
-  clientId,
-  clientSecret,
-  redirectUri
+    authUrl,
+    code,
+    clientId,
+    clientSecret,
+    redirectUri
 ) {
-  const response = await axios.post(
-    authUrl + "/api/v1/auth/authorize",
-    {
-      grantType: "authorization_code",
-      code: code,
-      redirectUri: redirectUri,
-      clientId: clientId,
-      clientSecret: clientSecret,
-    },
-    {
-      headers: { "Content-Type": "application/json" },
-    }
-  );
+    try {
+        const response = await axios.post(
+            authUrl + "/api/v1/auth/authorize",
+            {
+                grantType: "authorization_code",
+                code: code,
+                redirectUri: redirectUri,
+                clientId: clientId,
+                clientSecret: clientSecret,
+            },
+            {
+                headers: {"Content-Type": "application/json"},
+            }
+        );
 
-  return response.data;
+        return response.data;
+    } catch (error) {
+        console.error("Error exchanging token:", error);
+        return null;
+    }
 }
 
 /**
@@ -71,49 +76,49 @@ async function exchangeToken(
  * @returns {Function} - Express middleware function
  */
 const VerifyAccount = (requiredPermissions) => {
-  return async (req, res, next) => {
-    const accessToken = req.headers.authorization?.split(" ")[1];
-    if (!accessToken) {
-      return res.status(401).json({ error: "Access token is required" });
-    }
+    return async (req, res, next) => {
+        const accessToken = req.headers.authorization?.split(" ")[1];
+        if (!accessToken) {
+            return res.status(401).json({error: "Access token is required"});
+        }
 
-    // Check if token is in cache
-    if (tokenCache.has(accessToken)) {
-      req.user = tokenCache.get(accessToken);
-      return next();
-    }
+        // Check if token is in cache
+        if (tokenCache.has(accessToken)) {
+            req.user = tokenCache.get(accessToken);
+            return next();
+        }
 
-    try {
-      const decoded = jwt.verify(accessToken, process.env.JWT_SECRET);
-      if (!isValid(decoded, requiredPermissions)) {
-        return res.status(403).json({ error: "Invalid permissions" });
-      }
-      tokenCache.set(accessToken, decoded);
-      req.user = decoded;
-      return next();
-    } catch (error) {
-      try {
-        const userResponse = await axios.get(
-          `${process.env.AUTH_URL}/api/user`,
-          {
-            headers: {
-              Authorization: `Bearer ${accessToken}`,
-            },
-          }
-        );
+        try {
+            const decoded = jwt.verify(accessToken, process.env.JWT_SECRET);
+            if (!isValid(decoded, requiredPermissions)) {
+                return res.status(403).json({error: "Invalid permissions"});
+            }
+            tokenCache.set(accessToken, decoded);
+            req.user = decoded;
+            return next();
+        } catch (error) {
+            try {
+                const userResponse = await axios.get(
+                    `${process.env.AUTH_URL}/api/user`,
+                    {
+                        headers: {
+                            Authorization: `Bearer ${accessToken}`,
+                        },
+                    }
+                );
 
-        if (!isValid(userResponse.data, requiredPermissions)) {
-          return res.status(403).json({ error: "Invalid permissions" });
-        }
+                if (!isValid(userResponse.data, requiredPermissions)) {
+                    return res.status(403).json({error: "Invalid permissions"});
+                }
 
-        tokenCache.set(accessToken, userResponse.data);
-        req.user = userResponse.data;
-        return next();
-      } catch (networkError) {
-        return res.status(500).json({ error: "Error validating token" });
-      }
-    }
-  };
+                tokenCache.set(accessToken, userResponse.data);
+                req.user = userResponse.data;
+                return next();
+            } catch (networkError) {
+                return res.status(500).json({error: "Error validating token"});
+            }
+        }
+    };
 };
 
 /**
@@ -123,13 +128,13 @@ const VerifyAccount = (requiredPermissions) => {
  * @returns {boolean} - Returns true if the decoded token has all the required permissions, false otherwise.
  */
 function isValid(decodedToken, requiredPermissions) {
-  return requiredPermissions.every((permission) =>
-    decodedToken.permissions.includes(permission)
-  );
+    return requiredPermissions.every((permission) =>
+        decodedToken.permissions.includes(permission)
+    );
 }
 
 module.exports = {
-  VerifyAccount,
-  exchangeToken,
-  verifyJWT,
+    VerifyAccount,
+    exchangeToken,
+    verifyJWT,
 };