Merge branch 'task-dependency-v3' of https://github.com/Real-Dev-Squad/website-backend into task-dependency-v3

Author: vinit717

constants/monitor.js

@@ -0,0 +1,15 @@
+const RESOURCE_CREATED_SUCCESSFULLY = "Resource created successfully.";
+const RESOURCE_UPDATED_SUCCESSFULLY = "Resource updated successfully.";
+const RESOURCE_RETRIEVED_SUCCESSFULLY = "Resource retrieved successfully.";
+const RESOURCE_NOT_FOUND = "Resource not found.";
+const RESOURCE_ALREADY_TRACKED = "Resource is already being tracked.";
+
+const RESPONSE_MESSAGES = {
+  RESOURCE_CREATED_SUCCESSFULLY,
+  RESOURCE_UPDATED_SUCCESSFULLY,
+  RESOURCE_RETRIEVED_SUCCESSFULLY,
+  RESOURCE_NOT_FOUND,
+  RESOURCE_ALREADY_TRACKED,
+};
+
+module.exports = { RESPONSE_MESSAGES };

constants/rateLimiting.js

@@ -0,0 +1,8 @@
+const TOO_MANY_REQUESTS = {
+  ERROR_TYPE: "Too Many Requests",
+  STATUS_CODE: 429,
+};
+
+module.exports = {
+  TOO_MANY_REQUESTS,
+};

constants/roles.js

@@ -4,6 +4,7 @@ const ROLES = {
   APPOWNER: "app_owner",
   MEMBER: "member",
   ARCHIVED: "archived",
+  INDISCORD: "in_discord",
 };
 
 module.exports = ROLES;

constants/users.js

@@ -13,6 +13,7 @@ const USER_STATUS = {
 const ALLOWED_FILTER_PARAMS = {
   ITEM_TAG: ["levelId", "levelName", "levelValue", "tagId"],
   USER_STATE: ["state"],
+  ROLE: ["role"],
 };
 
 module.exports = { profileStatus, USER_STATUS, ALLOWED_FILTER_PARAMS };

controllers/monitor.js

@@ -0,0 +1,188 @@
+const { Conflict, NotFound } = require("http-errors");
+const { INTERNAL_SERVER_ERROR_MESSAGE } = require("../constants/progresses");
+const {
+  createTrackedProgressDocument,
+  updateTrackedProgressDocument,
+  getTrackedProgressDocuments,
+} = require("../models/monitor");
+const { RESPONSE_MESSAGES } = require("../constants/monitor");
+const { RESOURCE_CREATED_SUCCESSFULLY, RESOURCE_UPDATED_SUCCESSFULLY, RESOURCE_RETRIEVED_SUCCESSFULLY } =
+  RESPONSE_MESSAGES;
+/**
+ * @typedef {Object} TrackedProgressRequestBody
+ * @property {string} type - The type of tracked progress ("user" or "task").
+ * @property {string} [userId] - The user ID (required if type is "user").
+ * @property {string} [taskId] - The task ID (required if type is "task").
+ * @property {boolean} monitored - Indicates if the progress is currently being tracked.
+ * @property {number} [frequency=1] - The frequency of tracking.By default 1 if not specified
+ */
+
+/**
+ * @typedef {Object} TrackedProgressResponseData
+ * @property {string} id - The ID of the tracked progress document.
+ * @property {string} type - The type of tracked progress ("user" or "task").
+ * @property {string} userId - The user ID.
+ * @property {boolean} monitored - Indicates if the progress is currently being tracked.
+ * @property {number} frequency - The frequency of tracking.
+ * @property {string} createdAt - The timestamp when the document was created.
+ * @property {string} updatedAt - The timestamp when the document was last updated.
+ */
+
+/**
+ * @typedef {Object} TrackedProgressResponse
+ * @property {TrackedProgressResponseData} data - The data of the tracked progress document.
+ * @property {string} message - The success message.
+ */
+
+/**
+ * Controller function for creating a tracked progress document.
+ *
+ * @param {Express.Request} req - The Express request object.
+ * @param {TrackedProgressRequestBody} req.body - The Request body object.
+ * @param {Express.Response} res - The Express response object.
+ * @returns {Promise<void>} - A Promise that resolves when the response has been sent.
+ */
+
+const createTrackedProgressController = async (req, res) => {
+  try {
+    const data = await createTrackedProgressDocument({ ...req.body });
+    return res.status(201).json({
+      message: RESOURCE_CREATED_SUCCESSFULLY,
+      data,
+    });
+  } catch (error) {
+    if (error instanceof Conflict) {
+      return res.status(409).json({
+        message: error.message,
+      });
+    } else if (error instanceof NotFound) {
+      return res.status(404).json({
+        message: error.message,
+      });
+    }
+    return res.status(500).json({
+      message: INTERNAL_SERVER_ERROR_MESSAGE,
+    });
+  }
+};
+
+/**
+ * @typedef {Object} UpdateTrackedProgressRequestParams
+ * @property {string} type - The type of tracked progress ("user" or "task").
+ * @property {string} id - The ID of the tracked progress document.
+ */
+
+/**
+ * @typedef {Object} UpdateTrackedProgressRequestBody
+ * @property {number} frequency - The frequency of tracking.
+ * @property {boolean} monitored - Indicates if the progress is currently being tracked.
+ */
+
+/**
+ * @typedef {Object} UpdateTrackedProgressResponseData
+ * @property {string} id - The ID of the tracked progress document.
+ * @property {string} createdAt - The timestamp when the document was created.
+ * @property {string} type - The type of tracked progress ("user" or "task").
+ * @property {string} userId - The user ID.
+ * @property {number} frequency - The frequency of tracking.
+ * @property {boolean} monitored - Indicates if the progress is currently being tracked.
+ * @property {string} updatedAt - The timestamp when the document was last updated.
+ */
+
+/**
+ * @typedef {Object} UpdateTrackedProgressResponse
+ * @property {UpdateTrackedProgressResponseData} data - The data of the tracked progress document.
+ * @property {string} message - The success message.
+ */
+
+/**
+ * Controller function for updating a tracked progress document.
+ *
+ * @param {Express.Request} req - The Express request object.
+ * @param {UpdateTrackedProgressRequestParams} req.params - The request path parameters.
+ * @param {UpdateTrackedProgressRequestBody} req.body - The request body object.
+ * @param {Express.Response} res - The Express response object.
+ * @returns {Promise<void>} - A Promise that resolves when the response has been sent.
+ */
+
+const updateTrackedProgressController = async (req, res) => {
+  try {
+    const data = await updateTrackedProgressDocument({ ...req });
+    return res.status(200).json({
+      data,
+      message: RESOURCE_UPDATED_SUCCESSFULLY,
+    });
+  } catch (error) {
+    if (error instanceof NotFound) {
+      return res.status(404).json({
+        message: error.message,
+      });
+    }
+    return res.status(500).json({
+      message: INTERNAL_SERVER_ERROR_MESSAGE,
+    });
+  }
+};
+
+/**
+ * @typedef {Object} GetTrackedProgressRequestParams
+ * @property {string} [type] - The type of tracked progress ("user" or "task").
+ * @property {string} [monitored] - Indicates if the progress is currently being tracked.
+ * @property {string} [userId] - The ID of the User who is currently being tracked.
+ * @property {string} [taskId] - The ID of the task which is currently being tracked.
+ */
+
+/**
+ * @typedef {Object} TrackedProgressData
+ * @property {string} id - The ID of the tracked progress document.
+ * @property {boolean} monitored - Indicates if the progress is currently being tracked.
+ * @property {string} createdAt - The timestamp when the document was created.
+ * @property {string} type - The type of tracked progress ("user" or "task").
+ * @property {string} [userId] - The user ID.
+ * @property {string} [taskId] - The task ID.
+ * @property {number} frequency - The frequency of tracking.
+ * @property {string} updatedAt - The timestamp when the document was last updated.
+ */
+
+/**
+ * @typedef {Object} GetTrackedProgressResponse
+ * @property {string} message - The success message.
+ * @property {TrackedProgressData | TrackedProgressData[]} data - The data of the tracked progress document(s).
+ */
+
+/**
+ * Controller function for retrieving tracked progress documents.
+ *
+ * @param {Express.Request} req - The Express request object.
+ * @param {Express.Response} res - The Express response object.
+ * @returns {Promise<void>} A Promise that resolves when the response has been sent.
+ */
+
+const getTrackedProgressController = async (req, res) => {
+  try {
+    const data = await getTrackedProgressDocuments({ ...req.query });
+    return res.status(200).json({
+      message: RESOURCE_RETRIEVED_SUCCESSFULLY,
+      data,
+    });
+  } catch (error) {
+    if (error instanceof NotFound) {
+      const response = {
+        message: error.message,
+      };
+      if (req.query.type) {
+        response.data = [];
+      }
+      return res.status(404).json(response);
+    }
+    return res.status(500).json({
+      message: INTERNAL_SERVER_ERROR_MESSAGE,
+    });
+  }
+};
+
+module.exports = {
+  createTrackedProgressController,
+  updateTrackedProgressController,
+  getTrackedProgressController,
+};

controllers/users.js

@@ -5,7 +5,7 @@ const logsQuery = require("../models/logs");
 const imageService = require("../services/imageService");
 const { profileDiffStatus } = require("../constants/profileDiff");
 const { logType } = require("../constants/logs");
-const { fetch } = require("../utils/fetch");
+
 const logger = require("../utils/logger");
 const obfuscate = require("../utils/obfuscate");
 const { getPaginationLink, getUsernamesFromPRs } = require("../utils/users");
@@ -24,7 +24,11 @@ const verifyUser = async (req, res) => {
     logger.error(`Error while verifying user: ${error}`);
     return res.boom.serverUnavailable(SOMETHING_WENT_WRONG);
   }
-  fetch(process.env.IDENTITY_SERVICE_URL, "POST", null, { userId }, { "Content-Type": "application/json" });
+  fetch(process.env.IDENTITY_SERVICE_URL, {
+    method: "POST",
+    body: { userId },
+    headers: { "Content-Type": "application/json" },
+  });
   return res.json({
     message: "Your request has been queued successfully",
   });
@@ -65,11 +69,40 @@ const getUserById = async (req, res) => {
  * @param res {Object} - Express response object
  */
 
+const removePersonalDetails = (user) => {
+  const { phone, email, ...safeUser } = user;
+  return safeUser;
+};
+
 const getUsers = async (req, res) => {
   try {
     const query = req.query?.query ?? "";
     const qualifiers = getQualifiers(query);
 
+    // getting user details by id if present.
+    if (req.query.id) {
+      const id = req.query.id;
+      let result;
+      try {
+        result = await userQuery.fetchUser({ userId: id });
+      } catch (error) {
+        logger.error(`Error while fetching user: ${error}`);
+        return res.boom.serverUnavailable(SOMETHING_WENT_WRONG);
+      }
+
+      if (!result.userExists) {
+        return res.boom.notFound("User doesn't exist");
+      }
+
+      const User = { ...result.user };
+      const user = removePersonalDetails(User);
+
+      return res.json({
+        message: "User returned successfully!",
+        user,
+      });
+    }
+
     if (qualifiers?.filterBy) {
       const allPRs = await getFilteredPRsOrIssues(qualifiers);
 

middlewares/rateLimiting.js

@@ -0,0 +1,52 @@
+const { RateLimiterMemory } = require("rate-limiter-flexible");
+const { TOO_MANY_REQUESTS } = require("../constants/rateLimiting");
+const { getRetrySeconds } = require("../utils/rateLimiting");
+
+// INFO: temporarily added here, will be take from env-var/config
+const opts = {
+  keyPrefix: "commonRateLimiter--login_fail_by_ip_per_minute",
+  points: 5,
+  duration: 30,
+  blockDuration: 60 * 10,
+};
+const globalRateLimiter = new RateLimiterMemory(opts);
+
+/**
+ * @param req object represents the HTTP request and has property for the request ip address
+ * @param res object represents the HTTP response that app sends when it get an HTTP request
+ * @param next indicates the next middelware function
+ * @returns Promise, which:
+ *  - `resolved`  with next middelware function call `next()`
+ *  - `resolved`  with response status set to 429 and message `Too Many Requests`  */
+async function commonRateLimiter(req, res, next) {
+  // INFO: get the clientIP when running behind a proxy
+  const ipAddress = req.headers["x-forwarded-for"] || req.socket.remoteAddress;
+  let retrySeconds = 0;
+  try {
+    const responseGlobalRateLimiter = await globalRateLimiter.get(ipAddress);
+    if (responseGlobalRateLimiter && responseGlobalRateLimiter.consumedPoints > opts.points) {
+      retrySeconds = getRetrySeconds(responseGlobalRateLimiter.msBeforeNext);
+    }
+    if (retrySeconds > 0) {
+      throw Error();
+    }
+    await globalRateLimiter.consume(ipAddress);
+    return next();
+  } catch (error) {
+    // INFO: sending raw seconds in response,``
+    // for letting API user decide how to represent this number.
+    retrySeconds = getRetrySeconds(error?.msBeforeNext, retrySeconds);
+    res.set({
+      "Retry-After": retrySeconds,
+      "X-RateLimit-Limit": opts.points,
+      "X-RateLimit-Remaining": error?.remainingPoints ?? 0,
+      "X-RateLimit-Reset": new Date(Date.now() + error?.msBeforeNext),
+    });
+    const message = `${TOO_MANY_REQUESTS.ERROR_TYPE}: Retry After ${retrySeconds} seconds, requests limit reached`;
+    return res.status(TOO_MANY_REQUESTS.STATUS_CODE).json({ message });
+  }
+}
+
+module.exports = {
+  commonRateLimiter,
+};