shuttlepro-shared 1.2.43 → 1.2.45

package/common/repositories/descriptionTemplates.repository.js

@@ -79,30 +79,6 @@ const findTemplateByFilter = async (
     ) || null
   );
 };
-const findAllTemplateByFilter = async (
-  filter,
-  bodyFilter = {},
-  workspaceId = null
-) => {
-  const allTemplates = await getCachedAllDescriptionTemplates();
-
-  // Filter by workspaceId if provided
-  let filteredTemplates = workspaceId
-    ? allTemplates.filter((desc) => desc.workspaceId === workspaceId)
-    : allTemplates;
-
-  return (
-    filteredTemplates.filter(
-      (item) =>
-        // Check direct properties of item
-        Object.entries(filter).every(([key, value]) => item[key] === value) &&
-        // If bodyFilter is provided, check inside item.body
-        Object.entries(bodyFilter).every(
-          ([key, value]) => item.body?.[key] === value
-        )
-    ) || null
-  );
-};
 const createOrUpdateTemplate = async (filter, data) => {
   const template = await DescriptionTemplate.findOneAndUpdate(filter, data, {
     upsert: true,
@@ -225,5 +201,4 @@ module.exports = {
   findTemplateById,
   deleteTemplatesByFilter,
   insertManyTemplates,
-  findAllTemplateByFilter,
 };

package/common/repositories/index.js

@@ -9,6 +9,7 @@ const settingRepository = require("./settings.repository");
 const socialMediaSettingRepository = require("./socialMediaSetting.repository");
 const notificationSettingRepository = require("./notificationSetting.repository");
 const chatMemberRepository = require("./chatMember.repository");
+const roleRepository = require("./role.repository");
 
 exports.module = {
   workspaceRepository,
@@ -22,4 +23,5 @@ exports.module = {
   socialMediaSettingRepository,
   notificationSettingRepository,
   chatMemberRepository,
+  roleRepository,
 };

package/common/repositories/role.repository.js

@@ -0,0 +1,329 @@
+const Role = require("../../models/Role");
+const { utils } = require("shuttlepro-utils");
+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;
+  }
+  return roles;
+};
+
+const updateCachedRoles = async () => {
+  const roles = await Role.find().populate("permissionId").lean().exec();
+  await setRedisData(CACHE_KEY_ALL, roles);
+};
+
+const getCachedDefaultRoles = async () => {
+  let defaultRoles = await getRedisData(CACHE_KEY_DEFAULT);
+  if (!defaultRoles) {
+    const data = await Role.find({ name: { $ne: "super" }, workspaceId: null })
+      .select("name")
+      .sort({ _id: -1 })
+      .lean()
+      .exec();
+
+    defaultRoles = data.map((d) => {
+      return {
+        id: d?._id,
+        name: utils.capitalize(d?.name),
+      };
+    });
+
+    await setRedisData(CACHE_KEY_DEFAULT, defaultRoles);
+  }
+  return defaultRoles;
+};
+
+const updateCachedDefaultRoles = async () => {
+  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),
+    };
+  });
+
+  await setRedisData(CACHE_KEY_DEFAULT, defaultRoles);
+};
+
+const createRole = async (roleData) => {
+  const newRole = await Role.create(roleData);
+  const createdRole = await Role.findById(newRole._id)
+    .populate("permissionId")
+    .lean()
+    .exec();
+  await updateCachedRoles();
+  return createdRole;
+};
+
+const findRoleById = async (id) => {
+  const roles = await getCachedRoles();
+  const role = roles.find((r) => r._id.toString() === id) || null;
+
+  if (role) return role;
+
+  // If not found in cache, query directly
+  return await Role.findById(id).populate("permissionId").lean().exec();
+};
+
+const findSingleRole = async (filter) => {
+  const roles = await getCachedRoles();
+  const role =
+    roles.find((r) =>
+      Object.entries(filter).every(([key, value]) => r[key] === value)
+    ) || null;
+
+  if (role) return role;
+
+  // If not found in cache, query directly
+  return await Role.findOne(filter).populate("permissionId").lean().exec();
+};
+
+const findRolesByPagination = async (body) => {
+  let { page, limit, workspaceId, query, status } = body;
+
+  page = parseInt(page, 10) || 1;
+  limit = parseInt(limit, 10) || 10;
+
+  const skip = (page - 1) * limit;
+
+  let obj = { workspaceId };
+  if (query) {
+    obj.name = { $regex: query, $options: "i" };
+  }
+  if (status) {
+    obj.status = status;
+  }
+
+  const totalRoles = await Role.countDocuments(obj);
+  const totalPages = Math.ceil(totalRoles / limit);
+
+  const roles = await Role.find(obj)
+    .sort({ _id: -1 })
+    .skip(skip)
+    .limit(limit)
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  return {
+    totalPages,
+    currentPage: page,
+    roles,
+  };
+};
+
+const findRoles = async (workspaceId) => {
+  const roles = await getCachedRoles();
+  return roles.filter((r) => r.workspaceId === workspaceId);
+};
+
+const findDefaultRoles = async () => {
+  return await getCachedDefaultRoles();
+};
+
+const updateRoleById = async (id, updateData) => {
+  const updateQuery = {
+    ...updateData,
+    ...(Array.isArray(updateData.logs) && {
+      $push: { logs: { $each: updateData.logs } },
+    }),
+  };
+  delete updateQuery.logs;
+
+  const updatedRole = await Role.findByIdAndUpdate(id, updateQuery, {
+    new: true,
+  })
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole) {
+    await updateCachedRoles();
+    // Update default roles cache if needed
+    if (!updatedRole.workspaceId) {
+      await updateCachedDefaultRoles();
+    }
+  }
+
+  return updatedRole;
+};
+
+const updateRoleByFilter = async (filter, updateData) => {
+  const updatedRole = await Role.findOneAndUpdate(filter, updateData, {
+    new: true,
+  })
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole) {
+    await updateCachedRoles();
+    // Update default roles cache if needed
+    if (!updatedRole.workspaceId) {
+      await updateCachedDefaultRoles();
+    }
+  }
+
+  return updatedRole;
+};
+
+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();
+    }
+  }
+
+  return result;
+};
+
+const addLogToRole = async (id, logData) => {
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $push: { logs: logData } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole) {
+    await updateCachedRoles();
+  }
+
+  return updatedRole;
+};
+
+const clearRoleLogs = async (id) => {
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $set: { logs: [] } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole) {
+    await updateCachedRoles();
+  }
+
+  return updatedRole;
+};
+
+const addPermissionToRole = async (id, permission) => {
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $push: { permissions: permission } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole) {
+    await updateCachedRoles();
+  }
+
+  return updatedRole;
+};
+
+const removePermissionFromRole = async (id, permission) => {
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $pull: { permissions: permission } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole) {
+    await updateCachedRoles();
+  }
+
+  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 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;
+};
+
+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;
+};
+
+module.exports = {
+  createRole,
+  findRoleById,
+  findSingleRole,
+  findRoles,
+  updateRoleById,
+  updateRoleByFilter,
+  updateRolesByFilter,
+  addLogToRole,
+  clearRoleLogs,
+  addPermissionToRole,
+  removePermissionFromRole,
+  deleteRoleById,
+  deleteSingleRole,
+  deleteManyRoles,
+  findRolesByPagination,
+  findDefaultRoles,
+};

package/common/repositories/userRole.repository.js

@@ -1,12 +1,68 @@
 const { UserRole } = require("../../models/UserRole");
+const { getRedisData, setRedisData } = require("../../config/redis");
 
-const createUserRole = async (data) => {
-  const newRole = new UserRole(data);
-  const savedRole = await newRole.save();
-  return savedRole;
+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 CACHE_KEY_USER_WORKSPACE_PREFIX = "userrole_workspace_";
+const CACHE_KEY_USER_PERMISSIONS_PREFIX = "user_permissions_";
+
+// Clear user workspace cache
+const clearUserWorkspaceCache = async (userId) => {
+  await setRedisData(
+    `${CACHE_KEY_USER_WORKSPACE_PREFIX}${userId}`,
+    null,
+    null,
+    0
+  );
 };
 
-const findUserRole = async (filter = {}) => {
+// Clear user permissions cache
+const clearUserPermissionsCache = async (workspaceId, userId) => {
+  const cacheKey = `${CACHE_KEY_USER_PERMISSIONS_PREFIX}${workspaceId}_${userId}`;
+  await setRedisData(cacheKey, null, null, 0);
+};
+
+// Get cached members
+const getCachedMembers = async (filter = {}) => {
+  const cacheKey =
+    Object.keys(filter).length > 0
+      ? `${CACHE_KEY_ALL_MEMBERS}_${JSON.stringify(filter)}`
+      : CACHE_KEY_ALL_MEMBERS;
+
+  let members = await getRedisData(cacheKey);
+
+  if (!members) {
+    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();
+
+    await setRedisData(cacheKey, members, null, 0);
+  }
+
+  return members;
+};
+
+// Update the cache for all members
+const updateCachedMembers = async (filter = {}) => {
+  const cacheKey =
+    Object.keys(filter).length > 0
+      ? `${CACHE_KEY_ALL_MEMBERS}_${JSON.stringify(filter)}`
+      : CACHE_KEY_ALL_MEMBERS;
+
   const members = await UserRole.find(filter)
     .select("userId role userShift roleId")
     .populate({
@@ -18,28 +74,279 @@ const findUserRole = async (filter = {}) => {
       path: "userId",
       match: { isDeleted: false, suspended: false },
       select: "firstName lastName role email picture userShift",
-    });
+    })
+    .lean()
+    .exec();
 
+  await setRedisData(cacheKey, members, null, 0);
   return members;
 };
 
+const createUserRole = async (data) => {
+  const newRole = new UserRole(data);
+  const savedRole = await newRole.save();
+
+  // Update cache
+  await updateCachedMembers();
+  if (data.userId) {
+    await clearUserWorkspaceCache(data.userId);
+    // Clear permissions cache if workspaceId exists
+    if (data.workspaceId) {
+      await clearUserPermissionsCache(data.workspaceId, data.userId);
+    }
+  }
+
+  return savedRole;
+};
+
+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 updateCachedMembers();
+    if (updatedRole.userId) {
+      await clearUserWorkspaceCache(updatedRole.userId);
+      // Clear permissions cache if workspaceId exists
+      if (updatedRole.workspaceId) {
+        await clearUserPermissionsCache(
+          updatedRole.workspaceId,
+          updatedRole.userId
+        );
+      }
+    }
+  }
+
   return updatedRole;
 };
 
 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 updateCachedMembers();
+    if (userId) {
+      await clearUserWorkspaceCache(userId);
+      // Clear permissions cache if workspaceId exists
+      if (workspaceId) {
+        await clearUserPermissionsCache(workspaceId, userId);
+      }
+    }
+  }
+
   return deletedRole;
 };
 
+const findUserWorkspaces = async (userId) => {
+  const cacheKey = `${CACHE_KEY_USER_WORKSPACE_PREFIX}${userId}`;
+  let userRoleWithWorkspaces = await getRedisData(cacheKey);
+  if (!userRoleWithWorkspaces) {
+    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.map((ur) => {
+      return {
+        ...ur?.workspaceId,
+        id: ur?.workspaceId?._id?.toString(),
+        _id: ur?.workspaceId?._id?.toString(),
+        role: ur?.roleId?.name || "",
+        permissions: ur?.roleId?.modulePermissions?.modules || [],
+      };
+    });
+    if (userRoleWithWorkspaces) {
+      await setRedisData(cacheKey, userRoleWithWorkspaces, null, 0);
+    }
+  }
+  return userRoleWithWorkspaces;
+};
+
+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 getUserRoleWithPermissions = async (workspaceId, userId) => {
+  const cacheKey = `${CACHE_KEY_USER_PERMISSIONS_PREFIX}${workspaceId}_${userId}`;
+  let cachedData = await getRedisData(cacheKey);
+
+  if (cachedData && cachedData.roleWithPermissions) {
+    return cachedData.roleWithPermissions;
+  }
+
+  try {
+    let data = await UserRole.findOne({
+      workspaceId: workspaceId,
+      userId: userId,
+    })
+      .populate({
+        path: "roleId",
+        select:
+          "id name userId userShift permissionId modulePermissions defaultModule",
+        populate: [{ path: "permissionId", select: "id name" }],
+      })
+      .lean()
+      .exec();
+
+    if (!data) {
+      return null;
+    }
+
+    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 || "",
+    };
+
+    // Store in cache with other permission data
+    const permissionsData = cachedData || {};
+    permissionsData.roleWithPermissions = roleWithPermissions;
+    await setRedisData(cacheKey, permissionsData, null, 0);
+
+    return roleWithPermissions;
+  } catch (err) {
+    console.error("Error in getUserRoleWithPermissions:", err);
+    return null;
+  }
+};
+
+const getUserPermissions = async (workspaceId, userId) => {
+  const cacheKey = `${CACHE_KEY_USER_PERMISSIONS_PREFIX}${workspaceId}_${userId}`;
+  let cachedData = await getRedisData(cacheKey);
+
+  if (cachedData && cachedData.permissions) {
+    return cachedData.permissions;
+  }
+
+  try {
+    let data = await UserRole.findOne({
+      workspaceId: workspaceId,
+      userId: userId,
+    })
+      .select("roleId userId")
+      .populate({
+        path: "roleId",
+        select: "modulePermissions",
+      })
+      .lean()
+      .exec();
+
+    if (!data) {
+      return null;
+    }
+
+    const permissions =
+      convertPermissionsArrayToObject(
+        data?.roleId?.modulePermissions?.modules
+      ) || null;
+
+    // Store in cache with other permission data
+    const permissionsData = cachedData || {};
+    permissionsData.permissions = permissions;
+    await setRedisData(cacheKey, permissionsData, null, 0);
+
+    return permissions;
+  } catch (err) {
+    console.error("Error in getUserPermissions:", err);
+    return null;
+  }
+};
+
+const getChannelsPermissions = async (workspaceId, userId) => {
+  const cacheKey = `${CACHE_KEY_USER_PERMISSIONS_PREFIX}${workspaceId}_${userId}`;
+  let cachedData = await getRedisData(cacheKey);
+
+  if (cachedData && cachedData.channelsPermissions) {
+    return cachedData.channelsPermissions;
+  }
+
+  try {
+    let data = await UserRole.findOne({
+      workspaceId: workspaceId,
+      userId: userId,
+    })
+      .select("roleId userId")
+      .populate({
+        path: "roleId",
+        select: "modulePermissions",
+      })
+      .lean()
+      .exec();
+
+    if (!data) {
+      return [];
+    }
+
+    const channelsPermissions =
+      convertPermissionsArrayToObject(
+        data?.roleId?.modulePermissions?.modules
+      )?.["conversations"]?.["integrationPermissions"] || [];
+
+    // Store in cache with other permission data
+    const permissionsData = cachedData || {};
+    permissionsData.channelsPermissions = channelsPermissions;
+    await setRedisData(cacheKey, permissionsData, null, 0);
+
+    return channelsPermissions;
+  } catch (err) {
+    console.error("Error in getChannelsPermissions:", err);
+    return [];
+  }
+};
+
 module.exports = {
   createUserRole,
   findUserRole,
   updateUserRole,
   deleteUserRole,
+  findUserWorkspaces,
+  getUserRoleWithPermissions,
+  getUserPermissions,
+  getChannelsPermissions,
 };

package/common/repositories/workspace.repository.js

@@ -28,7 +28,8 @@ const createWorkspace = async (data) => {
 
 const findWorkspaceById = async (id, select = []) => {
   const workspaces = await getCachedWorkspaces();
-  const workspace = workspaces.find((ws) => ws._id.toString() === id) || null;
+  const workspace =
+    workspaces.find((ws) => ws._id.toString() === id && !ws?.isDeleted) || null;
   if (workspace && select.length > 0) {
     return select.reduce((result, field) => {
       if (workspace[field] !== undefined) {
@@ -49,6 +50,16 @@ const findWorkspace = async (filter) => {
   );
 };
 
+const findSingleWorkspace = async (filter) => {
+  const cachedWorkspaces = await getCachedWorkspaces();
+  const cachedWorkspace = cachedWorkspaces.find((ws) =>
+    Object.entries(filter).every(([key, value]) => ws[key] === value)
+  );
+  if (cachedWorkspace) return cachedWorkspace;
+  const workspace = await Workspace.findOne(filter).lean().exec();
+  return workspace;
+};
+
 const findWorkspaceByIdAndQueueTracking = async (id) => {
   const workspaces = await getCachedWorkspaces();
   return (
@@ -75,6 +86,38 @@ const updateWorkspace = async (id, data) => {
   return updatedWorkspace;
 };
 
+const updateOneWorkspace = async (filter, update, options = {}) => {
+  const result = await Workspace.updateOne(filter, update, options).exec();
+  if (result.matchedCount > 0) {
+    await updateCachedWorkspaces();
+  }
+  return result;
+};
+
+const updateManyWorkspaces = async (filter, update, options = {}) => {
+  const result = await Workspace.updateMany(filter, update, options).exec();
+  if (result.matchedCount > 0) {
+    await updateCachedWorkspaces();
+  }
+  return result;
+};
+
+const findOneAndUpdateWorkspace = async (
+  filter,
+  update,
+  options = { new: true }
+) => {
+  const updatedWorkspace = await Workspace.findOneAndUpdate(
+    filter,
+    update,
+    options
+  ).exec();
+  if (updatedWorkspace) {
+    await updateCachedWorkspaces();
+  }
+  return updatedWorkspace;
+};
+
 const deleteWorkspace = async (id) => {
   const deletedWorkspace = await Workspace.findByIdAndDelete(id).exec();
   if (deletedWorkspace) {
@@ -85,10 +128,14 @@ const deleteWorkspace = async (id) => {
 
 module.exports = {
   createWorkspace,
-  findWorkspaceById,
   findWorkspace,
+  findSingleWorkspace,
+  findWorkspaceById,
   findWorkspaceByIdAndQueueTracking,
   findAllWorkspaces,
+  findOneAndUpdateWorkspace,
   updateWorkspace,
+  updateOneWorkspace,
+  updateManyWorkspaces,
   deleteWorkspace,
 };

package/config/redis.js

@@ -103,6 +103,7 @@ const addDataToRedisSet = async (key, value) => {
     return false;
   }
 };
+
 const removeDataFromRedisSet = async (key, value) => {
   try {
     await connectRedis();

package/models/UserRole.js

@@ -52,112 +52,6 @@ const userRoleSchema = new Schema(
 
 const UserRole = mongoose.model("UserRole", userRoleSchema);
 
-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 getUserRoleWithPermissions = async (workspaceId, userId) => {
-  try {
-    let data = await UserRole.findOne({
-      workspaceId: workspaceId,
-      userId: userId,
-    })
-      .populate({
-        path: "roleId",
-        select:
-          "id name userId userShift permissionId modulePermissions defaultModule",
-        populate: [{ path: "permissionId", select: "id name" }],
-      })
-      .lean()
-      .exec();
-    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 (err) {
-    console.error("Error in getUserRole:", err);
-    return null;
-  }
-};
-
-const getUserPermissions = async (workspaceId, userId) => {
-  try {
-    let data = await UserRole.findOne({
-      workspaceId: workspaceId,
-      userId: userId,
-    })
-      .select("roleId userId")
-      .populate({
-        path: "roleId",
-        select: "modulePermissions",
-      })
-      .lean()
-      .exec();
-    return (
-      convertPermissionsArrayToObject(
-        data?.roleId?.modulePermissions?.modules
-      ) || null
-    );
-  } catch (err) {
-    console.error("Error in getUserRole:", err);
-    return null;
-  }
-};
-
-const getChannelsPermissions = async (workspaceId, userId) => {
-  try {
-    let data = await UserRole.findOne({
-      workspaceId: workspaceId,
-      userId: userId,
-    })
-      .select("roleId userId")
-      .populate({
-        path: "roleId",
-        select: "modulePermissions",
-      })
-      .lean()
-      .exec();
-    return (
-      convertPermissionsArrayToObject(
-        data?.roleId?.modulePermissions?.modules
-      )?.["conversations"]?.["integrationPermissions"] || []
-    );
-  } catch (err) {
-    console.error("Error in getUserRole:", err);
-    return null;
-  }
-};
-
 module.exports = {
   UserRole,
-  getChannelsPermissions,
-  getUserPermissions,
-  getUserRoleWithPermissions,
 };

package/package.json

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