shuttlepro-shared 1.2.69 → 1.2.70

package/common/repositories/userRole.repository.js

@@ -1,191 +1,578 @@
+// const { UserRole } = require("../../models/UserRole");
+// const { getRedisData, setRedisData } = require("../../config/redis");
+
+// const defaultSelect =
+//   "iconUrl thumbUrl name productsCount ordersCount contact email address websiteUrl facebookUrl twitterUrl instagramUrl members defaultModule";
+
+// // Cache keys
+// const CACHE_KEY_ALL_MEMBERS = "userroles_all_members";
+
+// const getCachedMembers = async (filter = {}) => {
+//   try {
+//     let members = await getRedisData(CACHE_KEY_ALL_MEMBERS);
+
+//     if (!members) {
+//       members = await UserRole.find()
+//         .select("userId role userShift roleId workspaceId")
+//         .populate({
+//           path: "roleId",
+//           select: "id name userId userShift permissionId modulePermissions",
+//           populate: [{ path: "permissionId", select: "id name" }],
+//         })
+//         .populate({
+//           path: "userId",
+//           match: { isDeleted: false, suspended: false },
+//           select: "firstName lastName role email picture userShift _id",
+//         })
+//         .lean()
+//         .exec();
+
+//       members = members?.filter((m) => m?.userId && m?.roleId) || [];
+//       await setRedisData(CACHE_KEY_ALL_MEMBERS, members);
+//     }
+
+//     const userIdFilter = filter.userId
+//       ? new Set(
+//           Array.isArray(filter.userId)
+//             ? filter.userId.map((id) => id.toString())
+//             : [filter.userId.toString()]
+//         )
+//       : null;
+
+//     const roleIdFilter = filter.roleId
+//       ? Array.isArray(filter.roleId)
+//         ? new Set(filter.roleId.map((id) => id.toString()))
+//         : typeof filter.roleId === "object"
+//         ? filter.roleId
+//         : new Set([filter.roleId.toString()])
+//       : null;
+
+//     return members.filter((member) => {
+//       // Optimize userId filter
+//       if (userIdFilter && !userIdFilter.has(member.userId?._id?.toString())) {
+//         return false;
+//       }
+
+//       // Optimize roleId filter
+//       if (roleIdFilter) {
+//         if (roleIdFilter instanceof Set) {
+//           const roleIdStr =
+//             member.roleId?._id?.toString() ?? member.roleId?.id?.toString();
+//           if (!roleIdFilter.has(roleIdStr)) return false;
+//         } else if (typeof roleIdFilter === "object") {
+//           for (const [key, value] of Object.entries(roleIdFilter)) {
+//             const roleVal = key.includes(".")
+//               ? key.split(".").reduce((obj, k) => obj?.[k], member.roleId)
+//               : member.roleId?.[key];
+//             if (Array.isArray(value)) {
+//               if (!value.includes(roleVal)) return false;
+//             } else if (roleVal !== value) {
+//               return false;
+//             }
+//           }
+//         }
+//       }
+
+//       // General filters
+//       for (const [key, value] of Object.entries(filter)) {
+//         if (key === "userId" || key === "roleId") continue;
+
+//         const memberValue = key.includes(".")
+//           ? key.split(".").reduce((obj, prop) => obj?.[prop], member)
+//           : member[key];
+
+//         if (Array.isArray(value)) {
+//           if (!value.includes(memberValue)) return false;
+//         } else if (typeof value === "object" && value !== null) {
+//           for (const [subKey, subVal] of Object.entries(value)) {
+//             if (memberValue?.[subKey] !== subVal) return false;
+//           }
+//         } else {
+//           if (memberValue !== value) return false;
+//         }
+//       }
+
+//       return true;
+//     });
+//   } catch (error) {
+//     console.error("Error fetching cached members:", error);
+//     return [];
+//   }
+// };
+
+// // Update the cache for all members
+// const updateCachedMembers = async (filter = {}) => {
+//   try {
+//     const members = await UserRole.find(filter)
+//       .select("userId role userShift roleId")
+//       .populate({
+//         path: "roleId",
+//         select: "id name userId userShift permissionId modulePermissions",
+//         populate: [{ path: "permissionId", select: "id name" }],
+//       })
+//       .populate({
+//         path: "userId",
+//         match: { isDeleted: false, suspended: false },
+//         select: "firstName lastName role email picture userShift",
+//       })
+//       .lean()
+//       .exec();
+
+//     const validMembers =
+//       members?.filter((member) => member?.userId && member?.roleId) || [];
+
+//     await setRedisData(CACHE_KEY_ALL_MEMBERS, validMembers);
+
+//     return validMembers;
+//   } catch (error) {
+//     console.error("Error updating cached members:", error);
+//     return [];
+//   }
+// };
+
+// // Comprehensive cache update method
+// const updateAllRelatedCaches = async (userId, workspaceId) => {
+//   try {
+//     await updateCachedMembers();
+//   } catch (error) {
+//     console.error("Error updating related caches:", error);
+//   }
+// };
+
+// // Find single user role by filter
+// const findSingleUserRoleByFilter = async (
+//   filter = {},
+//   populateOptions = {}
+// ) => {
+//   const defaultPopulateOptions = {
+//     rolePopulate: {
+//       path: "roleId",
+//       select: "id name userId userShift permissionId modulePermissions",
+//       populate: [{ path: "permissionId", select: "id name" }],
+//     },
+//     userPopulate: {
+//       path: "userId",
+//       match: { isDeleted: false, suspended: false },
+//       select: "firstName lastName role email picture userShift",
+//     },
+//   };
+//   const mergedPopulateOptions = {
+//     rolePopulate: {
+//       ...defaultPopulateOptions.rolePopulate,
+//       ...populateOptions.rolePopulate,
+//     },
+//     userPopulate: {
+//       ...defaultPopulateOptions.userPopulate,
+//       ...populateOptions.userPopulate,
+//     },
+//   };
+//   return await UserRole.findOne(filter)
+//     .populate(mergedPopulateOptions.rolePopulate)
+//     .populate(mergedPopulateOptions.userPopulate)
+//     .lean()
+//     .exec();
+// };
+
+// const convertPermissionsArrayToObject = (originalArray) => {
+//   return originalArray?.reduce((acc, item) => {
+//     const { id, actions, integrationPermissions, ...extras } = item;
+//     const formattedExtras = {};
+//     if (extras.deletable !== undefined) {
+//       formattedExtras.deletable = extras.deletable;
+//     }
+//     if (extras.createUpdateable !== undefined) {
+//       formattedExtras.createUpdateable = extras.createUpdateable;
+//     }
+//     acc[id] = {
+//       actions: Object.keys(actions).filter((action) => actions[action]),
+//       ...formattedExtras,
+//       ...(integrationPermissions && {
+//         integrationPermissions: Object.entries(integrationPermissions)
+//           .filter(([_, allowed]) => allowed)
+//           .map(([key]) => key),
+//       }),
+//     };
+//     return acc;
+//   }, {});
+// };
+
+// const createUserRole = async (data) => {
+//   const savedRole = await UserRole.create(data);
+
+//   // Update all related caches
+//   await updateAllRelatedCaches(
+//     savedRole?.userId?.toString(),
+//     savedRole?.workspaceId?.toString()
+//   );
+
+//   return savedRole;
+// };
+
+// const findOneAndUpdateUserRole = async ({
+//   workspaceId,
+//   userId,
+//   userShift,
+//   role,
+// }) => {
+//   const updatedRole = await UserRole.findOneAndUpdate(
+//     { workspaceId, userId },
+//     { $set: { userShift, role } },
+//     { new: true, upsert: false }
+//   ).exec();
+//   if (updatedRole) {
+//     await updateAllRelatedCaches(userId, workspaceId);
+//   }
+//   return updatedRole;
+// };
+
+// const findUserRole = async (filter = {}) => {
+//   return await getCachedMembers(filter);
+// };
+
+// const updateUserRole = async (id, data) => {
+//   const updatedRole = await UserRole.findByIdAndUpdate(id, data, {
+//     new: true,
+//   }).exec();
+//   if (updatedRole) {
+//     await updateAllRelatedCaches(updatedRole.userId, updatedRole.workspaceId);
+//   }
+//   return updatedRole;
+// };
+
+// const deleteUserRoleByFilter = async (filter) => {
+//   const roleToDelete = await UserRole.findOne(filter).exec();
+//   const deletedRole = await UserRole.findOneAndDelete(filter).exec();
+//   if (deletedRole) {
+//     await updateAllRelatedCaches(
+//       roleToDelete?.userId,
+//       roleToDelete?.workspaceId
+//     );
+//   }
+//   return deletedRole;
+// };
+
+// const deleteUserRole = async (id) => {
+//   const role = await UserRole.findById(id).exec();
+//   const userId = role?.userId;
+//   const workspaceId = role?.workspaceId;
+//   const deletedRole = await UserRole.findByIdAndDelete(id).exec();
+//   if (deletedRole) {
+//     await updateAllRelatedCaches(userId, workspaceId);
+//   }
+//   return deletedRole;
+// };
+
+// const findUserWorkspaces = async (userId) => {
+//   let userRoleWithWorkspaces = await UserRole.find({ userId: userId })
+//     .select("userId roleId workspaceId")
+//     .populate({
+//       path: "roleId",
+//       select: "id name userId userShift permissionId modulePermissions",
+//       populate: [{ path: "permissionId", select: "id name" }],
+//     })
+//     .populate({
+//       path: "workspaceId",
+//       select: defaultSelect,
+//       match: { isDeleted: false },
+//     })
+//     .lean()
+//     .exec();
+//   userRoleWithWorkspaces = userRoleWithWorkspaces
+//     ?.filter((userRole) => userRole?.workspaceId)
+//     ?.filter((userRole) => userRole?.roleId)
+//     ?.map((ur) => {
+//       return {
+//         ...ur?.workspaceId,
+//         id: ur?.workspaceId?._id?.toString(),
+//         _id: ur?.workspaceId?._id?.toString(),
+//         role: ur?.roleId?.name || "",
+//         permissions: ur?.roleId?.modulePermissions?.modules || [],
+//       };
+//     });
+//   return userRoleWithWorkspaces || [];
+// };
+
+// const getUserPermissions = async (workspaceId, userId) => {
+//   try {
+//     let members = await getCachedMembers({ workspaceId, userId });
+//     console.log(members, "members");
+//     if (members?.length) {
+//       return (
+//         convertPermissionsArrayToObject(
+//           members?.[0]?.roleId?.modulePermissions?.modules
+//         ) || null
+//       );
+//     }
+//     return null;
+//   } catch (err) {
+//     console.error("Error in getUserPermissions:", err);
+//     return null;
+//   }
+// };
+
+// const getUserRoleWithPermissions = async (workspaceId, userId) => {
+//   try {
+//     let members = await getCachedMembers({ workspaceId, userId });
+//     console.log(members, "members");
+//     if (members?.length) {
+//       let data = members?.[0];
+//       const roleWithPermissions = {
+//         ...data,
+//         roleId: data?.roleId?._id?.toString() || "",
+//         role: data?.roleId?.name || "",
+//         permissions:
+//           convertPermissionsArrayToObject(
+//             data?.roleId?.modulePermissions?.modules
+//           ) || [],
+//         parentRole: data?.roleId?.permissionId?.name || "",
+//         parentRoleId: data?.roleId?.permissionId?._id?.toString() || "",
+//         defaultModule: data?.roleId?.defaultModule || "",
+//       };
+//       return roleWithPermissions || null;
+//     }
+//     return null;
+//   } catch (err) {
+//     console.error("Error in getUserRoleWithPermissions:", err);
+//     return null;
+//   }
+// };
+
+// const getChannelsPermissions = async (workspaceId, userId) => {
+//   try {
+//     let members = await getCachedMembers({ workspaceId, userId });
+//     console.log(members, "members");
+//     if (members?.length) {
+//       let data = members?.[0];
+//       return (
+//         convertPermissionsArrayToObject(
+//           data?.roleId?.modulePermissions?.modules
+//         )?.["conversations"]?.["integrationPermissions"] || []
+//       );
+//     }
+//     return [];
+//   } catch (err) {
+//     console.error("Error in getChannelsPermissions:", err);
+//     return [];
+//   }
+// };
+
+// module.exports = {
+//   createUserRole,
+//   findUserRole,
+//   updateUserRole,
+//   deleteUserRoleByFilter,
+//   deleteUserRole,
+//   findUserWorkspaces,
+//   getUserRoleWithPermissions,
+//   getUserPermissions,
+//   getChannelsPermissions,
+//   findOneAndUpdateUserRole,
+//   findSingleUserRoleByFilter,
+//   getCachedMembers,
+//   updateCachedMembers,
+// };
+
 const { UserRole } = require("../../models/UserRole");
 const { getRedisData, setRedisData } = require("../../config/redis");
 
-const defaultSelect =
-  "iconUrl thumbUrl name productsCount ordersCount contact email address websiteUrl facebookUrl twitterUrl instagramUrl members defaultModule";
+// Default selection and population configurations
+const DEFAULT_USER_ROLE_CONFIG = {
+  select: {
+    userRole: "userId role userShift roleId workspaceId",
+    role: "id name userId userShift permissionId modulePermissions",
+    permission: "id name",
+    user: "firstName lastName role email picture userShift _id",
+  },
+  match: {
+    user: { isDeleted: false, suspended: false },
+  },
+};
 
-// Cache keys
+// Cache key constant
 const CACHE_KEY_ALL_MEMBERS = "userroles_all_members";
-const CACHE_KEY_USER_PERMISSIONS_PREFIX = "user_permissions_";
 
-const getCachedMembers = async (filter = {}) => {
-  try {
-    let members = await getRedisData(CACHE_KEY_ALL_MEMBERS);
-
-    if (!members) {
-      members = await UserRole.find()
-        .select("userId role userShift roleId workspaceId")
-        .populate({
-          path: "roleId",
-          select: "id name userId userShift permissionId modulePermissions",
-          populate: [{ path: "permissionId", select: "id name" }],
-        })
-        .populate({
-          path: "userId",
-          match: { isDeleted: false, suspended: false },
-          select: "firstName lastName role email picture userShift _id",
-        })
-        .lean()
-        .exec();
-
-      members = members?.filter((m) => m?.userId && m?.roleId) || [];
-      await setRedisData(CACHE_KEY_ALL_MEMBERS, members);
-    }
+/**
+ * Construct a flexible query builder for UserRole with advanced filtering and population
+ * @param {Object} options - Query configuration options
+ * @returns {Promise} Mongoose query result
+ */
+const buildUserRoleQuery = async (options = {}) => {
+  const {
+    filter = {},
+    select = {},
+    populate = {},
+    cacheKey = CACHE_KEY_ALL_MEMBERS,
+    useCache = true,
+    lean = true,
+  } = options;
+
+  // Merge default configurations with provided options
+  const mergedSelect = {
+    userRole: select.userRole || DEFAULT_USER_ROLE_CONFIG.select.userRole,
+    role: select.role || DEFAULT_USER_ROLE_CONFIG.select.role,
+    permission: select.permission || DEFAULT_USER_ROLE_CONFIG.select.permission,
+    user: select.user || DEFAULT_USER_ROLE_CONFIG.select.user,
+  };
 
-    const userIdFilter = filter.userId
-      ? new Set(
-          Array.isArray(filter.userId)
-            ? filter.userId.map((id) => id.toString())
-            : [filter.userId.toString()]
-        )
-      : null;
+  const mergedMatch = {
+    user: {
+      ...DEFAULT_USER_ROLE_CONFIG.match.user,
+      ...(select.userMatch || {}),
+    },
+  };
 
-    const roleIdFilter = filter.roleId
-      ? Array.isArray(filter.roleId)
-        ? new Set(filter.roleId.map((id) => id.toString()))
-        : typeof filter.roleId === "object"
-        ? filter.roleId
-        : new Set([filter.roleId.toString()])
-      : null;
+  // Populate configuration with fallback defaults
+  const populateConfig = [
+    {
+      path: "roleId",
+      select: mergedSelect.role,
+      populate: {
+        path: "permissionId",
+        select: mergedSelect.permission,
+      },
+    },
+    {
+      path: "userId",
+      match: mergedMatch.user,
+      select: mergedSelect.user,
+    },
+    ...(populate.additional || []),
+  ];
 
-    return members.filter((member) => {
-      // Optimize userId filter
-      if (userIdFilter && !userIdFilter.has(member.userId?._id?.toString())) {
-        return false;
-      }
+  try {
+    // Check cache first if useCache is true
+    if (useCache) {
+      let cachedData = await getRedisData(cacheKey);
 
-      // Optimize roleId filter
-      if (roleIdFilter) {
-        if (roleIdFilter instanceof Set) {
-          const roleIdStr =
-            member.roleId?._id?.toString() ?? member.roleId?.id?.toString();
-          if (!roleIdFilter.has(roleIdStr)) return false;
-        } else if (typeof roleIdFilter === "object") {
-          for (const [key, value] of Object.entries(roleIdFilter)) {
-            const roleVal = key.includes(".")
-              ? key.split(".").reduce((obj, k) => obj?.[k], member.roleId)
-              : member.roleId?.[key];
-            if (Array.isArray(value)) {
-              if (!value.includes(roleVal)) return false;
-            } else if (roleVal !== value) {
-              return false;
-            }
-          }
-        }
+      if (cachedData) {
+        return applyAdvancedFiltering(cachedData, filter);
       }
+    }
 
-      // General filters
-      for (const [key, value] of Object.entries(filter)) {
-        if (key === "userId" || key === "roleId") continue;
-
-        const memberValue = key.includes(".")
-          ? key.split(".").reduce((obj, prop) => obj?.[prop], member)
-          : member[key];
-
-        if (Array.isArray(value)) {
-          if (!value.includes(memberValue)) return false;
-        } else if (typeof value === "object" && value !== null) {
-          for (const [subKey, subVal] of Object.entries(value)) {
-            if (memberValue?.[subKey] !== subVal) return false;
-          }
-        } else {
-          if (memberValue !== value) return false;
-        }
-      }
+    // Construct base query
+    let query = UserRole.find(filter).select(mergedSelect.userRole);
 
-      return true;
+    // Apply population
+    populateConfig.forEach((config) => {
+      query = query.populate(config);
     });
+
+    // Execute query
+    const results = lean ? await query.lean().exec() : await query.exec();
+
+    // Filter out invalid entries and cache results
+    const validResults = results.filter(
+      (result) => result?.userId && result?.roleId
+    );
+
+    // Cache results if useCache is true
+    if (useCache) {
+      await setRedisData(cacheKey, validResults);
+    }
+
+    // Apply advanced filtering
+    return applyAdvancedFiltering(validResults, filter);
   } catch (error) {
-    console.error("Error fetching cached members:", error);
+    console.error("Error in buildUserRoleQuery:", error);
     return [];
   }
 };
 
-// Update the cache for all members
-const updateCachedMembers = async (filter = {}) => {
+/**
+ * Apply advanced filtering with nested property support
+ * @param {Array} data - Data to filter
+ * @param {Object} filter - Filter conditions
+ * @returns {Array} Filtered results
+ */
+const applyAdvancedFiltering = (data, filter = {}) => {
+  if (!data || data.length === 0) return [];
+
+  return data.filter((item) => {
+    for (const [key, value] of Object.entries(filter)) {
+      // Skip special filtering keys
+      if (key === "userId" || key === "roleId") continue;
+
+      // Handle nested property access
+      const itemValue = key.includes(".")
+        ? key.split(".").reduce((obj, prop) => obj?.[prop], item)
+        : item[key];
+
+      // Complex filtering logic
+      if (Array.isArray(value)) {
+        if (!value.includes(itemValue)) return false;
+      } else if (typeof value === "object" && value !== null) {
+        for (const [subKey, subVal] of Object.entries(value)) {
+          if (itemValue?.[subKey] !== subVal) return false;
+        }
+      } else {
+        if (itemValue !== value) return false;
+      }
+    }
+    return true;
+  });
+};
+
+/**
+ * Wrapper functions using the new query builder
+ */
+const getCachedMembers = async (filter = {}) => buildUserRoleQuery({ filter });
+
+const findUserRole = async (filter = {}) => buildUserRoleQuery({ filter });
+
+const updateCachedMembers = async (filter = {}) =>
+  buildUserRoleQuery({
+    filter,
+    cacheKey: CACHE_KEY_ALL_MEMBERS,
+  });
+
+const findSingleUserRoleByFilter = async (filter = {}, options = {}) => {
+  const results = await buildUserRoleQuery({
+    filter,
+    ...options,
+  });
+  return results[0] || null;
+};
+
+const getUserPermissions = async (workspaceId, userId) => {
   try {
-    const members = await UserRole.find(filter)
-      .select("userId role userShift roleId")
-      .populate({
-        path: "roleId",
-        select: "id name userId userShift permissionId modulePermissions",
-        populate: [{ path: "permissionId", select: "id name" }],
-      })
-      .populate({
-        path: "userId",
-        match: { isDeleted: false, suspended: false },
-        select: "firstName lastName role email picture userShift",
-      })
-      .lean()
-      .exec();
-
-    const validMembers =
-      members?.filter((member) => member?.userId && member?.roleId) || [];
-
-    await setRedisData(CACHE_KEY_ALL_MEMBERS, validMembers);
-
-    return validMembers;
-  } catch (error) {
-    console.error("Error updating cached members:", error);
-    return [];
+    const members = await getCachedMembers({ workspaceId, userId });
+    return members?.[0]?.roleId?.modulePermissions?.modules
+      ? convertPermissionsArrayToObject(
+          members[0].roleId.modulePermissions.modules
+        )
+      : null;
+  } catch (err) {
+    console.error("Error in getUserPermissions:", err);
+    return null;
   }
 };
 
-// Comprehensive cache update method
-const updateAllRelatedCaches = async (userId, workspaceId) => {
+const getUserRoleWithPermissions = async (workspaceId, userId) => {
   try {
-    // Update all members cache
-    await updateCachedMembers();
-
-    // Clear user permissions cache
-    if (workspaceId && userId) {
-      await clearUserPermissionsCache(workspaceId, userId);
+    const members = await getCachedMembers({ workspaceId, userId });
+    if (members?.length) {
+      const data = members[0];
+      return {
+        ...data,
+        roleId: data?.roleId?._id?.toString() || "",
+        role: data?.roleId?.name || "",
+        permissions:
+          convertPermissionsArrayToObject(
+            data?.roleId?.modulePermissions?.modules
+          ) || [],
+        parentRole: data?.roleId?.permissionId?.name || "",
+        parentRoleId: data?.roleId?.permissionId?._id?.toString() || "",
+        defaultModule: data?.roleId?.defaultModule || "",
+      };
     }
-  } catch (error) {
-    console.error("Error updating related caches:", error);
+    return null;
+  } catch (err) {
+    console.error("Error in getUserRoleWithPermissions:", err);
+    return null;
   }
 };
 
-// Clear user permissions cache
-const clearUserPermissionsCache = async (workspaceId, userId) => {
-  const cacheKey = `${CACHE_KEY_USER_PERMISSIONS_PREFIX}${workspaceId}_${userId}`;
-  await setRedisData(cacheKey, null, null, 0);
-};
-
-// Find single user role by filter
-const findSingleUserRoleByFilter = async (
-  filter = {},
-  populateOptions = {}
-) => {
-  const defaultPopulateOptions = {
-    rolePopulate: {
-      path: "roleId",
-      select: "id name userId userShift permissionId modulePermissions",
-      populate: [{ path: "permissionId", select: "id name" }],
-    },
-    userPopulate: {
-      path: "userId",
-      match: { isDeleted: false, suspended: false },
-      select: "firstName lastName role email picture userShift",
-    },
-  };
-  const mergedPopulateOptions = {
-    rolePopulate: {
-      ...defaultPopulateOptions.rolePopulate,
-      ...populateOptions.rolePopulate,
-    },
-    userPopulate: {
-      ...defaultPopulateOptions.userPopulate,
-      ...populateOptions.userPopulate,
-    },
-  };
-  return await UserRole.findOne(filter)
-    .populate(mergedPopulateOptions.rolePopulate)
-    .populate(mergedPopulateOptions.userPopulate)
-    .lean()
-    .exec();
-};
-
+// Existing utility function
 const convertPermissionsArrayToObject = (originalArray) => {
   return originalArray?.reduce((acc, item) => {
     const { id, actions, integrationPermissions, ...extras } = item;
@@ -209,160 +596,66 @@ const convertPermissionsArrayToObject = (originalArray) => {
   }, {});
 };
 
+// Existing methods (simplified)
 const createUserRole = async (data) => {
   const savedRole = await UserRole.create(data);
-
-  // Update all related caches
-  await updateAllRelatedCaches(
-    savedRole?.userId?.toString(),
-    savedRole?.workspaceId?.toString()
-  );
-
+  await updateCachedMembers();
   return savedRole;
 };
 
-const findOneAndUpdateUserRole = async ({
-  workspaceId,
-  userId,
-  userShift,
-  role,
-}) => {
-  const updatedRole = await UserRole.findOneAndUpdate(
-    { workspaceId, userId },
-    { $set: { userShift, role } },
-    { new: true, upsert: false }
-  ).exec();
-  if (updatedRole) {
-    await updateAllRelatedCaches(userId, workspaceId);
-  }
-  return updatedRole;
-};
-
-const findUserRole = async (filter = {}) => {
-  return await getCachedMembers(filter);
-};
-
 const updateUserRole = async (id, data) => {
   const updatedRole = await UserRole.findByIdAndUpdate(id, data, {
     new: true,
   }).exec();
   if (updatedRole) {
-    await updateAllRelatedCaches(updatedRole.userId, updatedRole.workspaceId);
+    await updateCachedMembers();
   }
   return updatedRole;
 };
 
-const deleteUserRoleByFilter = async (filter) => {
-  const roleToDelete = await UserRole.findOne(filter).exec();
-  const deletedRole = await UserRole.findOneAndDelete(filter).exec();
-  if (deletedRole) {
-    await updateAllRelatedCaches(
-      roleToDelete?.userId,
-      roleToDelete?.workspaceId
-    );
-  }
-  return deletedRole;
-};
-
 const deleteUserRole = async (id) => {
   const role = await UserRole.findById(id).exec();
-  const userId = role?.userId;
-  const workspaceId = role?.workspaceId;
   const deletedRole = await UserRole.findByIdAndDelete(id).exec();
   if (deletedRole) {
-    await updateAllRelatedCaches(userId, workspaceId);
+    await updateCachedMembers();
   }
   return deletedRole;
 };
 
 const findUserWorkspaces = async (userId) => {
-  let userRoleWithWorkspaces = await UserRole.find({ userId: userId })
-    .select("userId roleId workspaceId")
-    .populate({
-      path: "roleId",
-      select: "id name userId userShift permissionId modulePermissions",
-      populate: [{ path: "permissionId", select: "id name" }],
-    })
-    .populate({
-      path: "workspaceId",
-      select: defaultSelect,
-      match: { isDeleted: false },
-    })
-    .lean()
-    .exec();
-  userRoleWithWorkspaces = userRoleWithWorkspaces
-    ?.filter((userRole) => userRole?.workspaceId)
-    ?.filter((userRole) => userRole?.roleId)
-    ?.map((ur) => {
-      return {
-        ...ur?.workspaceId,
-        id: ur?.workspaceId?._id?.toString(),
-        _id: ur?.workspaceId?._id?.toString(),
-        role: ur?.roleId?.name || "",
-        permissions: ur?.roleId?.modulePermissions?.modules || [],
-      };
-    });
-  return userRoleWithWorkspaces || [];
-};
-
-const getUserPermissions = async (workspaceId, userId) => {
-  try {
-    let members = await getCachedMembers({ workspaceId, userId });
-    console.log(members, "members");
-    if (members?.length) {
-      return (
-        convertPermissionsArrayToObject(
-          members?.[0]?.roleId?.modulePermissions?.modules
-        ) || null
-      );
-    }
-    return null;
-  } catch (err) {
-    console.error("Error in getUserPermissions:", err);
-    return null;
-  }
-};
-
-const getUserRoleWithPermissions = async (workspaceId, userId) => {
-  try {
-    let members = await getCachedMembers({ workspaceId, userId });
-    console.log(members, "members");
-    if (members?.length) {
-      let data = members?.[0];
-      const roleWithPermissions = {
-        ...data,
-        roleId: data?.roleId?._id?.toString() || "",
-        role: data?.roleId?.name || "",
-        permissions:
-          convertPermissionsArrayToObject(
-            data?.roleId?.modulePermissions?.modules
-          ) || [],
-        parentRole: data?.roleId?.permissionId?.name || "",
-        parentRoleId: data?.roleId?.permissionId?._id?.toString() || "",
-        defaultModule: data?.roleId?.defaultModule || "",
-      };
-      return roleWithPermissions || null;
-    }
-    return null;
-  } catch (err) {
-    console.error("Error in getUserRoleWithPermissions:", err);
-    return null;
-  }
+  const userRoles = await buildUserRoleQuery({
+    filter: { userId },
+    populate: {
+      additional: [
+        {
+          path: "workspaceId",
+          select:
+            "iconUrl thumbUrl name productsCount ordersCount contact email address websiteUrl facebookUrl twitterUrl instagramUrl members defaultModule",
+          match: { isDeleted: false },
+        },
+      ],
+    },
+  });
+
+  return userRoles
+    .filter((userRole) => userRole.workspaceId)
+    .map((ur) => ({
+      ...ur.workspaceId,
+      id: ur.workspaceId?._id?.toString(),
+      _id: ur.workspaceId?._id?.toString(),
+      role: ur.roleId?.name || "",
+      permissions: ur.roleId?.modulePermissions?.modules || [],
+    }));
 };
 
 const getChannelsPermissions = async (workspaceId, userId) => {
   try {
-    let members = await getCachedMembers({ workspaceId, userId });
-    console.log(members, "members");
-    if (members?.length) {
-      let data = members?.[0];
-      return (
-        convertPermissionsArrayToObject(
-          data?.roleId?.modulePermissions?.modules
+    const members = await getCachedMembers({ workspaceId, userId });
+    return members?.[0]?.roleId?.modulePermissions?.modules
+      ? convertPermissionsArrayToObject(
+          members[0].roleId.modulePermissions.modules
         )?.["conversations"]?.["integrationPermissions"] || []
-      );
-    }
-    return [];
+      : [];
   } catch (err) {
     console.error("Error in getChannelsPermissions:", err);
     return [];
@@ -373,14 +666,13 @@ module.exports = {
   createUserRole,
   findUserRole,
   updateUserRole,
-  deleteUserRoleByFilter,
   deleteUserRole,
   findUserWorkspaces,
   getUserRoleWithPermissions,
   getUserPermissions,
   getChannelsPermissions,
-  findOneAndUpdateUserRole,
   findSingleUserRoleByFilter,
   getCachedMembers,
   updateCachedMembers,
+  buildUserRoleQuery, // Expose the new flexible query builder
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shuttlepro-shared",
-  "version": "1.2.69",
+  "version": "1.2.70",
   "description": "",
   "main": "index.js",
   "scripts": {