shuttlepro-shared 1.2.85 → 1.2.87

package/common/repositories/role.repository.js

@@ -1,61 +1,83 @@
 const Role = require("../../models/Role");
 const { getRedisData, setRedisData } = require("../../config/redis");
 
-const CACHE_KEY_ALL = "roles_all";
-const CACHE_KEY_DEFAULT = "roles_default";
-
-const getCachedRoles = async () => {
-  let roles = await getRedisData(CACHE_KEY_ALL);
-  if (!roles) {
-    roles = await Role.find().populate("permissionId").lean().exec();
-    await setRedisData(CACHE_KEY_ALL, roles);
-  } else {
-    roles = roles;
+// Cache keys
+const ROLES = "roles";
+const DEFAULT_ROLES = "default_roles";
+const CACHE_TIME = 3600 * 2;
+
+// Update the cache for workspace roles
+const updateCachedRoles = async (workspaceId) => {
+  try {
+    const roles = await Role.find({ workspaceId })
+      .populate("permissionId")
+      .lean()
+      .exec();
+    await setRedisData(workspaceId, roles, ROLES, CACHE_TIME);
+    return roles;
+  } catch (error) {
+    console.error("Error updating cached roles:", error);
+    return [];
   }
-  return roles;
 };
 
-const updateCachedRoles = async () => {
-  const roles = await Role.find().populate("permissionId").lean().exec();
-  await setRedisData(CACHE_KEY_ALL, roles);
+// Get roles from cache or database for a specific workspace
+const getRoles = async (workspaceId) => {
+  let roles = await getRedisData(workspaceId, ROLES);
+  if (!roles || roles?.length === 0) {
+    roles = await Role.find({ workspaceId })
+      .populate("permissionId")
+      .lean()
+      .exec();
+    await setRedisData(workspaceId, roles, ROLES, CACHE_TIME);
+  }
+  return roles;
 };
 
-const getCachedDefaultRoles = async () => {
-  let defaultRoles = await getRedisData(CACHE_KEY_DEFAULT);
-  if (!defaultRoles) {
+// Update default roles cache (system-wide roles with no workspace)
+const updateCachedDefaultRoles = async () => {
+  try {
     const data = await Role.find({ name: { $ne: "super" }, workspaceId: null })
       .select("name")
       .sort({ _id: -1 })
       .lean()
       .exec();
 
-    defaultRoles = data.map((d) => {
+    const defaultRoles = data.map((d) => {
       return {
         id: d?._id,
         name: d?.name,
       };
     });
 
-    await setRedisData(CACHE_KEY_DEFAULT, defaultRoles);
+    await setRedisData("system", defaultRoles, DEFAULT_ROLES, CACHE_TIME);
+    return defaultRoles;
+  } catch (error) {
+    console.error("Error updating cached default roles:", error);
+    return [];
   }
-  return defaultRoles;
 };
 
-const updateCachedDefaultRoles = async () => {
-  const data = await Role.find({ name: { $ne: "super" }, workspaceId: null })
-    .select("name")
-    .sort({ _id: -1 })
-    .lean()
-    .exec();
+// Get default roles from cache or database
+const getDefaultRoles = async () => {
+  let defaultRoles = await getRedisData("system", DEFAULT_ROLES);
+  if (!defaultRoles || defaultRoles?.length === 0) {
+    const data = await Role.find({ name: { $ne: "super" }, workspaceId: null })
+      .select("name")
+      .sort({ _id: -1 })
+      .lean()
+      .exec();
 
-  const defaultRoles = data.map((d) => {
-    return {
-      id: d?._id,
-      name: utils.capitalize(d?.name),
-    };
-  });
+    defaultRoles = data.map((d) => {
+      return {
+        id: d?._id,
+        name: d?.name,
+      };
+    });
 
-  await setRedisData(CACHE_KEY_DEFAULT, defaultRoles);
+    await setRedisData("system", defaultRoles, DEFAULT_ROLES, CACHE_TIME);
+  }
+  return defaultRoles;
 };
 
 const createRole = async (roleData) => {
@@ -64,31 +86,56 @@ const createRole = async (roleData) => {
     .populate("permissionId")
     .lean()
     .exec();
-  await updateCachedRoles();
+
+  if (createdRole.workspaceId) {
+    await updateCachedRoles(createdRole.workspaceId);
+  } else {
+    // If it's a default/system role
+    await updateCachedDefaultRoles();
+  }
+
   return createdRole;
 };
 
-const findRoleById = async (id) => {
-  const roles = await getCachedRoles();
-  const role = roles.find((r) => r._id.toString() === id) || null;
+const findRoleById = async (id, workspaceId) => {
+  const roles = await getRoles(workspaceId);
+  const role = roles.find((r) => r._id.toString() === id);
 
   if (role) return role;
 
   // If not found in cache, query directly
-  return await Role.findById(id).populate("permissionId").lean().exec();
+  const freshRole = await Role.findById(id)
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (freshRole && freshRole.workspaceId?.toString() === workspaceId) {
+    // Update the cache with the new data
+    await updateCachedRoles(workspaceId);
+  }
+  return freshRole;
 };
 
 const findSingleRole = async (filter) => {
-  const roles = await getCachedRoles();
-  const role =
-    roles.find((r) =>
+  const workspaceId = filter.workspaceId;
+  if (workspaceId) {
+    const roles = await getRoles(workspaceId);
+    const role = roles.find((r) =>
       Object.entries(filter).every(([key, value]) => r[key] === value)
-    ) || null;
+    );
 
-  if (role) return role;
+    if (role) return role;
+  }
 
-  // If not found in cache, query directly
-  return await Role.findOne(filter).populate("permissionId").lean().exec();
+  // If not found in cache or no workspaceId provided, query directly
+  const freshRole = await Role.findOne(filter)
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (freshRole && freshRole.workspaceId) {
+    // Update the cache with the new data
+    await updateCachedRoles(freshRole.workspaceId);
+  }
+  return freshRole;
 };
 
 const findRolesByPagination = async (body) => {
@@ -126,12 +173,11 @@ const findRolesByPagination = async (body) => {
 };
 
 const findRoles = async (workspaceId) => {
-  const roles = await getCachedRoles();
-  return roles.filter((r) => r.workspaceId === workspaceId);
+  return await getRoles(workspaceId);
 };
 
 const findDefaultRoles = async () => {
-  return await getCachedDefaultRoles();
+  return await getDefaultRoles();
 };
 
 const updateRoleById = async (id, updateData) => {
@@ -151,7 +197,9 @@ const updateRoleById = async (id, updateData) => {
     .exec();
 
   if (updatedRole) {
-    await updateCachedRoles();
+    if (updatedRole.workspaceId) {
+      await updateCachedRoles(updatedRole.workspaceId);
+    }
     // Update default roles cache if needed
     if (!updatedRole.workspaceId) {
       await updateCachedDefaultRoles();
@@ -170,7 +218,9 @@ const updateRoleByFilter = async (filter, updateData) => {
     .exec();
 
   if (updatedRole) {
-    await updateCachedRoles();
+    if (updatedRole.workspaceId) {
+      await updateCachedRoles(updatedRole.workspaceId);
+    }
     // Update default roles cache if needed
     if (!updatedRole.workspaceId) {
       await updateCachedDefaultRoles();
@@ -182,20 +232,21 @@ const updateRoleByFilter = async (filter, updateData) => {
 
 const updateRolesByFilter = async (filter, updateData) => {
   const result = await Role.updateMany(filter, updateData, { new: true });
-
   if (result.matchedCount > 0) {
-    await updateCachedRoles();
-
-    // Check if we need to update default roles cache
-    if (!filter.workspaceId || filter.workspaceId === null) {
-      await updateCachedDefaultRoles();
+    if (filter.workspaceId) {
+      await updateCachedRoles(filter.workspaceId);
+    } else {
+      if (!filter.workspaceId || filter.workspaceId === null) {
+        await updateCachedDefaultRoles();
+      }
     }
   }
-
   return result;
 };
 
 const addLogToRole = async (id, logData) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
   const updatedRole = await Role.findByIdAndUpdate(
     id,
     { $push: { logs: logData } },
@@ -205,14 +256,15 @@ const addLogToRole = async (id, logData) => {
     .lean()
     .exec();
 
-  if (updatedRole) {
-    await updateCachedRoles();
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
   }
-
   return updatedRole;
 };
 
 const clearRoleLogs = async (id) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
   const updatedRole = await Role.findByIdAndUpdate(
     id,
     { $set: { logs: [] } },
@@ -221,15 +273,15 @@ const clearRoleLogs = async (id) => {
     .populate("permissionId")
     .lean()
     .exec();
-
-  if (updatedRole) {
-    await updateCachedRoles();
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
   }
-
   return updatedRole;
 };
 
 const addPermissionToRole = async (id, permission) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
   const updatedRole = await Role.findByIdAndUpdate(
     id,
     { $push: { permissions: permission } },
@@ -238,15 +290,16 @@ const addPermissionToRole = async (id, permission) => {
     .populate("permissionId")
     .lean()
     .exec();
-
-  if (updatedRole) {
-    await updateCachedRoles();
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
   }
-
   return updatedRole;
 };
 
 const removePermissionFromRole = async (id, permission) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
+
   const updatedRole = await Role.findByIdAndUpdate(
     id,
     { $pull: { permissions: permission } },
@@ -256,56 +309,23 @@ const removePermissionFromRole = async (id, permission) => {
     .lean()
     .exec();
 
-  if (updatedRole) {
-    await updateCachedRoles();
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
   }
 
   return updatedRole;
 };
 
-const deleteRoleById = async (id) => {
-  const deletedRole = await Role.findByIdAndDelete(id).lean().exec();
-
-  if (deletedRole) {
-    await updateCachedRoles();
-    // Update default roles cache if needed
-    if (!deletedRole.workspaceId) {
-      await updateCachedDefaultRoles();
-    }
-  }
-
-  return deletedRole;
+const deleteRoleById = async (id, workspaceId) => {
+  return await Role.deleteOne({ _id: id }).exec();
 };
 
 const deleteSingleRole = async (filter) => {
-  const deletedRole = await Role.findOneAndDelete(filter).lean().exec();
-
-  if (deletedRole) {
-    await updateCachedRoles();
-    // Update default roles cache if needed
-    if (!deletedRole.workspaceId) {
-      await updateCachedDefaultRoles();
-    }
-  }
-
-  return deletedRole;
+  return await Role.deleteOne(filter).exec();
 };
 
 const deleteManyRoles = async (filter) => {
-  // Check if we need to update default roles cache
-  const includesDefaultRoles =
-    !filter.workspaceId || filter.workspaceId === null;
-
-  const result = await Role.deleteMany(filter);
-
-  if (result.deletedCount > 0) {
-    await updateCachedRoles();
-    if (includesDefaultRoles) {
-      await updateCachedDefaultRoles();
-    }
-  }
-
-  return result;
+  return await Role.deleteMany(filter);
 };
 
 module.exports = {
@@ -325,4 +345,6 @@ module.exports = {
   deleteManyRoles,
   findRolesByPagination,
   findDefaultRoles,
+  updateCachedRoles,
+  updateCachedDefaultRoles,
 };

package/config/redis.js

@@ -81,8 +81,12 @@ const setRedisData = async (
     await connectRedis();
     const stringifiedValue = JSON.stringify(value);
     let result;
+
     if (field) {
       result = await client.hSet(key, field, stringifiedValue);
+      if (expiryInSeconds) {
+        await client.expire(key, expiryInSeconds);
+      }
     } else {
       result = expiryInSeconds
         ? await client.set(key, stringifiedValue, { EX: expiryInSeconds })
@@ -94,6 +98,7 @@ const setRedisData = async (
     return null;
   }
 };
+
 const addDataToRedisSet = async (key, value) => {
   try {
     await connectRedis();

package/package.json

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