propro-utils 1.4.76 → 1.4.78

package/middlewares/access_token.js

@@ -1,7 +1,7 @@
 require('dotenv').config();
 const axios = require('axios');
-const {getOrSetCache} = require('../utils/redis');
-const {checkIfUserExists} = require('./account_info');
+const { getOrSetCache } = require('../utils/redis');
+const { checkIfUserExists } = require('./account_info');
 
 /**
  * Middleware for authenticating and authorizing API requests.
@@ -34,53 +34,53 @@ const {checkIfUserExists} = require('./account_info');
  * });
  */
 const authValidation = (redisClient, userSchema, requiredPermissions = []) => {
-    return async (req, res, next) => {
-        try {
-            const accessToken =
-                req.cookies['x-access-token'] ||
-                req.headers.authorization?.split(' ')[1];
+  return async (req, res, next) => {
+    try {
+      const accessToken =
+        req.cookies['x-access-token'] ||
+        req.headers.authorization?.split(' ')[1];
 
-            if (!accessToken) {
-                return res.status(403).json({error: 'Access token is required'});
-            }
+      if (!accessToken) {
+        return res.status(403).json({ error: 'Access token is required' });
+      }
 
-            const fetchPermission = async () => {
-                const response = await axios.post(
-                    `${process.env.AUTH_URL}/api/v1/auth/validateToken`,
-                    {
-                        accessToken: accessToken,
-                        requiredPermissions: requiredPermissions,
-                    }
-                );
-                return response.data;
-            };
-            const cacheKey = `account:permissions:${accessToken}`;
-            const {accountId, validPermissions} = await getOrSetCache(
-                redisClient,
-                cacheKey,
-                fetchPermission,
-                1800
-            );
+      const fetchPermission = async () => {
+        const response = await axios.post(
+          `${process.env.AUTH_URL}/api/v1/auth/validateToken`,
+          {
+            accessToken: accessToken,
+            requiredPermissions: requiredPermissions,
+          }
+        );
+        return response.data;
+      };
+      const cacheKey = `account:permissions:${accessToken}`;
+      const { accountId, validPermissions } = await getOrSetCache(
+        redisClient,
+        cacheKey,
+        fetchPermission,
+        1800
+      );
 
-            if (!validPermissions) {
-                return res.status(403).json({error: 'Invalid permissions'});
-            }
+      if (!validPermissions) {
+        return res.status(403).json({ error: 'Invalid permissions' });
+      }
 
-            req.account = accountId;
+      req.account = accountId;
 
-            const user = await checkIfUserExists(userSchema, accountId);
-            if (!user) {
-                return res.status(403).json({error: 'User not found'});
-            }
-            req.user = user.id;
-            next();
-        } catch (error) {
-            if (error.response && error.response.status) {
-                next(new Error(error.response.data.message));
-            }
-            next(new Error('Error validating token'));
-        }
-    };
+      const user = await checkIfUserExists(userSchema, accountId);
+      if (!user) {
+        return res.status(403).json({ error: 'User not found' });
+      }
+      req.user = user.id;
+      next();
+    } catch (error) {
+      if (error.response && error.response.status) {
+        next(new Error(error.response.data.message));
+      }
+      next(new Error('Error validating token'));
+    }
+  };
 };
 
 module.exports = authValidation;

package/package.json

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

package/src/index.js

@@ -29,6 +29,7 @@ let _serverAuth, _clientAuth;
  * @param {boolean} [options.useClientAuth=false] - A boolean flag to enable client-side authentication.
  * @param {Object} [options.clientOptions={}] - Configuration options for client-side authentication.
  * @param {Schema} [userSchema] - The user schema to perform the operations on.
+ * @param {RedisClient} [redisClient] - The Redis client used for caching.
  *
  * @returns {Function} An Express middleware function.
  * ```
@@ -43,13 +44,14 @@ let _serverAuth, _clientAuth;
  *     additionalChecks: async (req) => { },
  *   },
  *   useClientAuth: false,
- * }, UserSchema));
+ * }, UserSchema, redisClient));
  * ```
  */
 class ProProAuthMiddleware {
-  constructor(options = {}, userSchema) {
+  constructor(options = {}, userSchema, redisClient) {
     this.options = options;
     this.userSchema = userSchema;
+    this.redisClient = redisClient;
     this.serverAuth = null;
     this.clientAuth = null;
 
@@ -77,7 +79,8 @@ class ProProAuthMiddleware {
     if (!this.serverAuth) {
       this.serverAuth = new ServerAuth(
         this.options.serverOptions,
-        this.userSchema
+        this.userSchema,
+        this.redisClient
       );
     }
     return this.serverAuth.middleware();

package/src/server/index.js

@@ -3,9 +3,14 @@ const {
   exchangeToken,
   formatRedirectUrl,
 } = require('./middleware/verifyToken');
-const { setAuthCookies } = require('./middleware/cookieUtils');
+const {
+  setAuthCookies,
+  clearAuthCookies,
+} = require('./middleware/cookieUtils');
 const { checkIfUserExists } = require('../../middlewares/account_info');
+const authValidation = require('../../middlewares/access_token');
 const axios = require('axios');
+const { Router } = require('express');
 
 /**
  * Middleware for handling authentication and authorization.
@@ -20,10 +25,11 @@ const axios = require('axios');
  * @param {string} [options.appName=process.env.APP_NAME] - The application name.
  * @param {string} [options.appUrl] - The URL of the client application.
  * @param {Schema} [userSchema] - The user schema to perform the operations on.
+ * @param {RedisClient} [redisClient] - The Redis client used for caching.
  * @returns {Function} - Express middleware function.
  */
 class AuthMiddleware {
-  constructor(options = {}, userSchema) {
+  constructor(options = {}, userSchema, redisClient) {
     this.options = {
       secret: options.secret || 'RESTFULAPIs',
       authUrl: options.authUrl || process.env.AUTH_URL,
@@ -35,6 +41,7 @@ class AuthMiddleware {
       appUrl: options.appUrl || process.env.APP_URL,
     };
     this.userSchema = userSchema;
+    this.redisClient = redisClient;
     this.router = Router();
     this.initializeRoutes();
   }
@@ -49,7 +56,11 @@ class AuthMiddleware {
     this.router.patch('/api/profile/email', this.handleEmailUpdate);
     this.router.patch('api/profile/2fa', this.handleTwoFactorAuth);
     this.router.patch('/api/profile/avatar', this.handleAvatarUpdate);
-    this.router.patch('api/app/settings', this.handleAppSettings);
+    this.router.patch(
+      'api/app/settings',
+      authValidation(this.redisClient, this.userSchema, ['user']),
+      this.handleAppSettings
+    );
   }
 
   handleAuth = (req, res) => {
@@ -126,7 +137,8 @@ class AuthMiddleware {
     try {
       await this.logoutUser(refreshToken);
       clearAuthCookies(res);
-      res.status(200).json({ redirectUrl: this.constructRedirectUrl() });
+      return this.handleAuth(req, res);
+      // this.res.status(200).json({ redirectUrl: this.constructRedirectUrl() });
     } catch (error) {
       console.error('Error logging out:', error);
       res.status(500).json({ error: 'Failed to logout' });
@@ -162,7 +174,10 @@ class AuthMiddleware {
 
   handleProfileUpdate = async (req, res) => {
     try {
-      const response = await this.proxyToAuthServer(req, '/api/v1/profile');
+      const response = await this.proxyToAuthServer(
+        req,
+        '/api/v1/accounts/profile'
+      );
       res.status(response.status).json(response.data);
     } catch (error) {
       this.handleProxyError(error, res);
@@ -206,7 +221,7 @@ class AuthMiddleware {
     try {
       const response = await this.proxyToAuthServer(
         req,
-        '/api/v1/profile/avatar'
+        '/api/v1/accounts/avatar'
       );
       res.status(response.status).json(response.data);
     } catch (error) {
@@ -244,7 +259,41 @@ class AuthMiddleware {
   handleAppSettings = async (req, res) => {
     try {
       const { settings } = req.body;
-      res.status(200).json({ message: 'App settings updated successfully' });
+      const userId = req.user;
+
+      if (!settings || typeof settings !== 'object') {
+        return res.status(400).json({ error: 'Invalid settings format' });
+      }
+
+      const user = await this.userSchema.findOne({ id: userId });
+
+      if (!user) {
+        return res.status(404).json({ error: 'User not found' });
+      }
+
+      if (!user.settings) {
+        user.settings = {};
+      }
+
+      Object.keys(settings).forEach(key => {
+        if (typeof settings[key] === 'object' && settings[key] !== null) {
+          user.settings[key] = { ...user.settings[key], ...settings[key] };
+        } else {
+          user.settings[key] = settings[key];
+        }
+      });
+
+      if ('dark_mode' in settings) {
+        user.dark_mode = settings.dark_mode;
+      }
+
+      await user.save();
+
+      res.status(200).json({
+        message: 'App settings updated successfully',
+        settings: user.settings,
+        dark_mode: user.dark_mode,
+      });
     } catch (error) {
       console.error('Error updating app settings:', error);
       res.status(500).json({ error: 'Failed to update app settings' });