feat: Implement pagination for lazy loading in

- Added feature-flag-based () lazy loading to .
- Introduced support for , , and __TEXT	__DATA	__OBJC	others	dec	hex query parameters for pagination.
- Validated query parameters and returned structured pagination metadata (, __TEXT	__DATA	__OBJC	others	dec	hex, , ).
- Updated response structure to include enriched group membership information.
- Modified test cases in :
  - Added tests for cursor-based lazy loading behavior.
  - Handled scenarios with and without cursors.
  - Verified error handling for database query failures.

Author: Achintya-Chatterjee

controllers/discordactions.js

@@ -119,22 +119,57 @@ const deleteGroupRole = async (req, res) => {
 };
 
 /**
- * Gets all group-roles
+ * Get Paginated All Group Roles with Lazy Loading
+ * Implements cursor-based lazy loading with "dev=true" feature flag.
  *
+ * @param req {Object} - Express request object
  * @param res {Object} - Express response object
  */
-
-const getPaginatedGroupRoles = async (req, res) => {
+const getPaginatedAllGroupRoles = async (req, res) => {
   try {
-    const isDevMode = req.query?.dev === "true";
-    if (isDevMode) {
-      const latestDoc = req.query?.latestDoc;
-      const { groups, newLatestDoc } = await discordRolesModel.getPaginatedGroupRoles(latestDoc);
+    const { page = 0, size = 10, cursor, dev } = req.query;
+
+    const pageNumber = parseInt(page, 10);
+    const limit = parseInt(size, 10) || 10;
+
+    if (limit < 1 || limit > 100) {
+      return res.boom.badRequest("Invalid size. Must be between 1 and 100.");
+    }
+
+    if (dev === "true") {
+      let query = discordRolesModel.orderBy("roleid").limit(limit + 1); // Fetch one extra for `hasMore`
+
+      if (cursor) {
+        const cursorDoc = await discordRolesModel.doc(cursor).get();
+        if (!cursorDoc.exists) {
+          return res.boom.badRequest("Invalid cursor.");
+        }
+        query = query.startAfter(cursorDoc);
+      }
+
+      const snapshot = await query.get();
+      const roles = snapshot.docs.slice(0, limit).map((doc) => ({
+        id: doc.id,
+        ...doc.data(),
+      }));
+      const nextCursor = snapshot.docs.length > limit ? snapshot.docs[limit - 1].id : null;
+      const hasMore = !!nextCursor;
+
       const discordId = req.userData?.discordId;
-      const groupsWithMembershipInfo = await discordRolesModel.enrichGroupDataWithMembershipInfo(discordId, groups);
+      const groupsWithMembershipInfo = await discordRolesModel.enrichGroupDataWithMembershipInfo(discordId, roles);
+
+      const next = nextCursor ? `/roles?cursor=${nextCursor}&page=${pageNumber + 1}&size=${limit}` : null;
+      const prev = pageNumber > 0 ? `/roles?cursor=${cursor}&page=${pageNumber - 1}&size=${limit}` : null;
+
       return res.json({
         message: "Roles fetched successfully!",
-        newLatestDoc: newLatestDoc,
+        data: {
+          page: pageNumber,
+          size: limit,
+          next,
+          prev,
+          hasMore,
+        },
         groups: groupsWithMembershipInfo,
       });
     }
@@ -146,7 +181,7 @@ const getPaginatedGroupRoles = async (req, res) => {
       groups: groupsWithMembershipInfo,
     });
   } catch (err) {
-    logger.error(`Error while getting roles: ${err}`);
+    logger.error(`Error while fetching paginated group roles: ${err}`);
     return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
   }
 };
@@ -546,7 +581,7 @@ const getUserDiscordInvite = async (req, res) => {
 module.exports = {
   getGroupsRoleId,
   createGroupRole,
-  getPaginatedGroupRoles,
+  getPaginatedAllGroupRoles,
   addGroupRoleToMember,
   deleteRole,
   updateDiscordImageForVerification,

middlewares/validators/discordactions.js

@@ -40,8 +40,24 @@ const validateUpdateUsersNicknameStatusBody = async (req, res, next) => {
   }
 };
 
+const validateLazyLoadingParams = async (req, res, next) => {
+  const schema = Joi.object({
+    page: Joi.number().integer().min(0).optional(),
+    size: Joi.number().integer().min(1).max(100).optional(),
+    cursor: Joi.string().optional(),
+  });
+
+  try {
+    req.query = await schema.validateAsync(req.query);
+    next();
+  } catch (error) {
+    res.boom.badRequest(error.message);
+  }
+};
+
 module.exports = {
   validateGroupRoleBody,
   validateMemberRoleBody,
   validateUpdateUsersNicknameStatusBody,
+  validateLazyLoadingParams,
 };

models/discordactions.js

@@ -126,24 +126,41 @@ const getAllGroupRoles = async () => {
   }
 };
 
-const getPaginatedGroupRoles = async (latestDoc) => {
+/**
+ * Get Paginated Group Roles
+ * Fetches group roles with support for lazy loading.
+ *
+ * @param {Object} options - Pagination options
+ * @param {string} options.cursor - Firestore document ID for cursor
+ * @param {number} options.limit - Maximum number of roles to fetch
+ * @returns {Promise<Object>} - Paginated roles with metadata
+ */
+const getPaginatedGroupRoles = async ({ cursor, limit }) => {
   try {
-    const data = await discordRoleModel
-      .orderBy("roleid")
-      .startAfter(latestDoc || 0)
-      .limit(18)
-      .get();
-    const groups = [];
-    data.forEach((doc) => {
-      const group = {
-        id: doc.id,
-        ...doc.data(),
-      };
-      groups.push(group);
-    });
-    return { groups, newLatestDoc: data.docs[data.docs.length - 1]?.data().roleid };
+    let query = discordRoleModel.orderBy("roleid").limit(limit + 1); // Fetch one extra for `hasMore`
+
+    if (cursor) {
+      const cursorDoc = await discordRoleModel.doc(cursor).get();
+      if (!cursorDoc.exists) {
+        throw new Error("Invalid cursor.");
+      }
+      query = query.startAfter(cursorDoc);
+    }
+
+    const snapshot = await query.get();
+    const roles = snapshot.docs.slice(0, limit).map((doc) => ({
+      id: doc.id,
+      ...doc.data(),
+    }));
+    const nextCursor = snapshot.docs.length > limit ? snapshot.docs[limit - 1].id : null;
+
+    return {
+      roles,
+      nextCursor,
+      hasMore: !!nextCursor,
+    };
   } catch (err) {
-    logger.error("Error in getting all group-roles", err);
+    logger.error(`Error in getPaginatedGroupRoles: ${err}`);
     throw err;
   }
 };

routes/discordactions.js

@@ -3,7 +3,7 @@ const authenticate = require("../middlewares/authenticate");
 const {
   createGroupRole,
   getGroupsRoleId,
-  getPaginatedGroupRoles,
+  getPaginatedAllGroupRoles,
   addGroupRoleToMember,
   deleteRole,
   updateDiscordImageForVerification,
@@ -21,6 +21,7 @@ const {
   validateGroupRoleBody,
   validateMemberRoleBody,
   validateUpdateUsersNicknameStatusBody,
+  validateLazyLoadingParams,
 } = require("../middlewares/validators/discordactions");
 const checkIsVerifiedDiscord = require("../middlewares/verifydiscord");
 const checkCanGenerateDiscordLink = require("../middlewares/checkCanGenerateDiscordLink");
@@ -33,7 +34,7 @@ const { authorizeAndAuthenticate } = require("../middlewares/authorizeUsersAndSe
 const router = express.Router();
 
 router.post("/groups", authenticate, checkIsVerifiedDiscord, validateGroupRoleBody, createGroupRole);
-router.get("/groups", authenticate, checkIsVerifiedDiscord, getPaginatedGroupRoles);
+router.get("/groups", authenticate, checkIsVerifiedDiscord, validateLazyLoadingParams, getPaginatedAllGroupRoles);
 router.delete("/groups/:groupId", authenticate, checkIsVerifiedDiscord, authorizeRoles([SUPERUSER]), deleteGroupRole);
 router.post("/roles", authenticate, checkIsVerifiedDiscord, validateMemberRoleBody, addGroupRoleToMember);
 router.get("/invite", authenticate, getUserDiscordInvite);

test/unit/models/discordactions.test.js

@@ -120,15 +120,28 @@ describe("discordactions", function () {
     });
 
     it("should return paginated group-roles from the database", async function () {
-      const result = await getPaginatedGroupRoles();
+      const result = await getPaginatedGroupRoles({ cursor: groupData, limit: 2 });
+
       expect(result).to.have.property("groups").that.is.an("array");
-      expect(result).to.have.property("newLatestDoc");
-      expect(result.groups.length).to.be.at.most(18);
+      expect(result.groups).to.have.lengthOf(2); // Verify the limit works
+      expect(result).to.have.property("newLatestDoc").that.is.a("string");
+      expect(result).to.have.property("hasMore").that.is.a("boolean");
+    });
+
+    it("should handle pagination without a cursor", async function () {
+      const result = await getPaginatedGroupRoles({ limit: 2 });
+
+      // eslint-disable-next-line no-undef
+      assert(orderByStub.calledOnce);
+      // eslint-disable-next-line no-undef
+      assert(startAfterStub.notCalled);
+      expect(result.groups).to.have.lengthOf(2);
     });
 
     it("should throw an error if getting group-roles fails", async function () {
       getStub.rejects(new Error("Database error"));
-      return getPaginatedGroupRoles().catch((err) => {
+
+      await getPaginatedGroupRoles({ cursor: groupData, limit: 2 }).catch((err) => {
         expect(err).to.be.an.instanceOf(Error);
         expect(err.message).to.equal("Database error");
       });