@oneuptime/common 8.0.5144 → 8.0.5151

package/Models/DatabaseModels/WorkspaceProjectAuthToken.ts

@@ -18,13 +18,20 @@ import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import Permission from "../../Types/Permission";
 
 export interface MiscData {
-  [key: string]: string;
+  [key: string]: any;
 }
 
 export interface SlackMiscData extends MiscData {
   teamId: string;
   teamName: string;
   botUserId: string;
+  channelCache?: {
+    [channelName: string]: {
+      id: string;
+      name: string;
+      lastUpdated: string;
+    };
+  };
 }
 
 @TenantColumn("projectId")

package/Server/API/BaseAPI.ts

@@ -235,13 +235,25 @@ export default class BaseAPI<
   ): Promise<void> {
     await this.onBeforeList(req, res);
 
-    const skip: PositiveNumber = req.query["skip"]
-      ? new PositiveNumber(req.query["skip"] as string)
-      : new PositiveNumber(0);
+    // Extract pagination parameters from query or body (for POST requests)
+    // Support both 'skip' and 'offset' parameters (offset is alias for skip)
+    let skipValue: number = 0;
+    let limitValue: number = DEFAULT_LIMIT;
+
+    if (req.query["skip"]) {
+      skipValue = parseInt(req.query["skip"] as string, 10) || 0;
+    } else if (req.body && req.body["skip"] !== undefined) {
+      skipValue = parseInt(req.body["skip"] as string, 10) || 0;
+    }
+
+    if (req.query["limit"]) {
+      limitValue = parseInt(req.query["limit"] as string, 10) || DEFAULT_LIMIT;
+    } else if (req.body && req.body["limit"] !== undefined) {
+      limitValue = parseInt(req.body["limit"] as string, 10) || DEFAULT_LIMIT;
+    }
 
-    const limit: PositiveNumber = req.query["limit"]
-      ? new PositiveNumber(req.query["limit"] as string)
-      : new PositiveNumber(DEFAULT_LIMIT);
+    const skip: PositiveNumber = new PositiveNumber(skipValue);
+    const limit: PositiveNumber = new PositiveNumber(limitValue);
 
     if (limit.toNumber() > LIMIT_PER_PROJECT) {
       throw new BadRequestException(

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -214,6 +214,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
             ).doesChannelExist({
               authToken: projectAuthToken,
               channelName: channelName,
+              projectId: data.projectId,
             });
 
           if (!channelExists) {
@@ -459,6 +460,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           workspaceType: workspaceType,
         }),
         sendMessageBeforeArchiving: data.sendMessageBeforeArchiving,
+        projectId: data.projectId,
       });
     }
   }
@@ -1032,6 +1034,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
                   } as WorkspacePayloadMarkdown,
                 ],
               },
+              projectId: data.projectId,
             });
           } catch (e) {
             logger.error("Error in sending message to channel");
@@ -1059,6 +1062,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
               }),
             workspaceUserIds: workspaceUserIds,
           },
+          projectId: data.projectId,
         });
       }
     }
@@ -1187,6 +1191,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
                     } as WorkspacePayloadMarkdown,
                   ],
                 },
+                projectId: data.projectId,
               },
             );
           } catch (e) {
@@ -1216,6 +1221,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           channelNames: channelNames,
           workspaceUserIds: workspaceUserIds,
         },
+        projectId: data.projectId,
       });
 
       // Log user invitations
@@ -1373,6 +1379,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         ).createChannel({
           authToken: data.projectOrUserAuthTokenForWorkspace,
           channelName: notificationChannel.channelName,
+          projectId: data.projectId,
         });
 
       const notificationWorkspaceChannel: NotificationRuleWorkspaceChannel = {

package/Server/Utils/Workspace/Slack/Actions/Incident.ts

@@ -225,6 +225,7 @@ export default class SlackIncidentActions {
         await SlackUtil.sendMessage({
           authToken: projectAuthToken,
           userId: botUserId,
+          projectId: slackRequest.projectId!,
           workspaceMessagePayload: {
             _type: "WorkspaceMessagePayload",
             channelIds: [slackChannelId],

package/Server/Utils/Workspace/Slack/Actions/ScheduledMaintenance.ts

@@ -280,6 +280,7 @@ export default class SlackScheduledMaintenanceActions {
         await SlackUtil.sendMessage({
           authToken: projectAuthToken,
           userId: botUserId,
+          projectId: slackRequest.projectId!,
           workspaceMessagePayload: {
             _type: "WorkspaceMessagePayload",
             channelIds: [slackChannelId],

package/Server/Utils/Workspace/Slack/Slack.ts

@@ -31,6 +31,8 @@ import { DropdownOption } from "../../../../UI/Components/Dropdown/Dropdown";
 import OneUptimeDate from "../../../../Types/Date";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
 import BadDataException from "../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../Types/ObjectID";
+import WorkspaceProjectAuthTokenService from "../../../Services/WorkspaceProjectAuthTokenService";
 
 export default class SlackUtil extends WorkspaceBase {
   public static isValidSlackIncomingWebhookUrl(
@@ -181,6 +183,7 @@ export default class SlackUtil extends WorkspaceBase {
     channelIds: Array<string>;
     authToken: string;
     sendMessageBeforeArchiving: WorkspacePayloadMarkdown;
+    projectId: ObjectID;
   }): Promise<void> {
     if (data.sendMessageBeforeArchiving) {
       await this.sendMessage({
@@ -193,6 +196,7 @@ export default class SlackUtil extends WorkspaceBase {
         },
         authToken: data.authToken,
         userId: data.userId,
+        projectId: data.projectId,
       });
     }
 
@@ -349,6 +353,7 @@ export default class SlackUtil extends WorkspaceBase {
     authToken: string;
     channelName: string;
     workspaceUserId: string;
+    projectId: ObjectID;
   }): Promise<void> {
     if (data.channelName && data.channelName.startsWith("#")) {
       // trim # from channel name
@@ -362,6 +367,7 @@ export default class SlackUtil extends WorkspaceBase {
       await this.getWorkspaceChannelFromChannelName({
         authToken: data.authToken,
         channelName: data.channelName,
+        projectId: data.projectId,
       })
     ).id;
 
@@ -376,31 +382,32 @@ export default class SlackUtil extends WorkspaceBase {
   public static override async createChannelsIfDoesNotExist(data: {
     authToken: string;
     channelNames: Array<string>;
+    projectId: ObjectID;
   }): Promise<Array<WorkspaceChannel>> {
     logger.debug("Creating channels if they do not exist with data:");
     logger.debug(data);
 
     const workspaceChannels: Array<WorkspaceChannel> = [];
-    const existingWorkspaceChannels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
-        authToken: data.authToken,
-      });
 
     for (let channelName of data.channelNames) {
-      // if channel name starts with #, remove it
+      // Normalize channel name
       if (channelName && channelName.startsWith("#")) {
         channelName = channelName.substring(1);
       }
-
-      // convert channel name to lowercase
       channelName = channelName.toLowerCase();
-
-      // replace spaces with hyphens
       channelName = channelName.replace(/\s+/g, "-");
 
-      if (existingWorkspaceChannels[channelName]) {
+      // Check if channel exists using optimized method
+      const existingChannel: WorkspaceChannel | null =
+        await this.getWorkspaceChannelByName({
+          authToken: data.authToken,
+          channelName: channelName,
+          projectId: data.projectId,
+        });
+
+      if (existingChannel) {
         logger.debug(`Channel ${channelName} already exists.`);
-        workspaceChannels.push(existingWorkspaceChannels[channelName]!);
+        workspaceChannels.push(existingChannel);
         continue;
       }
 
@@ -408,6 +415,7 @@ export default class SlackUtil extends WorkspaceBase {
       const channel: WorkspaceChannel = await this.createChannel({
         authToken: data.authToken,
         channelName: channelName,
+        projectId: data.projectId,
       });
 
       if (channel) {
@@ -425,26 +433,27 @@ export default class SlackUtil extends WorkspaceBase {
   public static override async getWorkspaceChannelFromChannelName(data: {
     authToken: string;
     channelName: string;
+    projectId: ObjectID;
   }): Promise<WorkspaceChannel> {
     logger.debug("Getting workspace channel ID from channel name with data:");
     logger.debug(data);
 
-    const channels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
+    const channel: WorkspaceChannel | null =
+      await this.getWorkspaceChannelByName({
         authToken: data.authToken,
+        channelName: data.channelName,
+        projectId: data.projectId,
       });
 
-    logger.debug("All workspace channels:");
-
-    if (!channels[data.channelName]) {
+    if (!channel) {
       logger.error("Channel not found.");
       throw new BadDataException("Channel not found.");
     }
 
-    logger.debug("Workspace channel ID obtained:");
-    logger.debug(channels[data.channelName]!.id);
+    logger.debug("Workspace channel obtained:");
+    logger.debug(channel);
 
-    return channels[data.channelName]!;
+    return channel;
   }
 
   @CaptureSpan()
@@ -584,6 +593,216 @@ export default class SlackUtil extends WorkspaceBase {
     return channels;
   }
 
+  @CaptureSpan()
+  public static async getChannelFromCache(data: {
+    projectId: ObjectID;
+    channelName: string;
+  }): Promise<WorkspaceChannel | null> {
+    logger.debug("Getting channel from cache with data:");
+    logger.debug(data);
+
+    const projectAuth: any =
+      await WorkspaceProjectAuthTokenService.getProjectAuth({
+        projectId: data.projectId,
+        workspaceType: WorkspaceType.Slack,
+      });
+
+    if (!projectAuth || !projectAuth.miscData) {
+      logger.debug("No project auth found or no misc data");
+      return null;
+    }
+
+    const miscData: any = projectAuth.miscData;
+    const channelCache: any = miscData.channelCache;
+
+    if (!channelCache || !channelCache[data.channelName]) {
+      logger.debug("Channel not found in cache");
+      return null;
+    }
+
+    const cachedChannelData: WorkspaceChannel = channelCache[
+      data.channelName
+    ] as WorkspaceChannel;
+    const channel: WorkspaceChannel = {
+      id: cachedChannelData.id,
+      name: cachedChannelData.name,
+      workspaceType: WorkspaceType.Slack,
+    };
+
+    logger.debug("Channel found in cache:");
+    logger.debug(channel);
+    return channel;
+  }
+
+  @CaptureSpan()
+  public static async updateChannelCache(data: {
+    projectId: ObjectID;
+    channelName: string;
+    channel: WorkspaceChannel;
+  }): Promise<void> {
+    logger.debug("Updating channel cache with data:");
+    logger.debug(data);
+
+    const projectAuth: any =
+      await WorkspaceProjectAuthTokenService.getProjectAuth({
+        projectId: data.projectId,
+        workspaceType: WorkspaceType.Slack,
+      });
+
+    if (!projectAuth) {
+      logger.debug("No project auth found, cannot update cache");
+      return;
+    }
+
+    const miscData: any = projectAuth.miscData || {};
+    const channelCache: any = miscData.channelCache || {};
+
+    // Update the cache
+    channelCache[data.channelName] = {
+      id: data.channel.id,
+      name: data.channel.name,
+      lastUpdated: new Date().toISOString(),
+    };
+
+    // Update miscData
+    miscData.channelCache = channelCache;
+
+    // Save back to database
+    await WorkspaceProjectAuthTokenService.refreshAuthToken({
+      projectId: data.projectId,
+      workspaceType: WorkspaceType.Slack,
+      authToken: projectAuth.authToken,
+      workspaceProjectId: projectAuth.workspaceProjectId,
+      miscData: miscData,
+    });
+
+    logger.debug("Channel cache updated successfully");
+  }
+
+  @CaptureSpan()
+  public static async getWorkspaceChannelByName(data: {
+    authToken: string;
+    channelName: string;
+    projectId: ObjectID;
+  }): Promise<WorkspaceChannel | null> {
+    logger.debug("Getting workspace channel by name with data:");
+    logger.debug(data);
+
+    // Normalize channel name
+    let normalizedChannelName: string = data.channelName;
+    if (normalizedChannelName && normalizedChannelName.startsWith("#")) {
+      normalizedChannelName = normalizedChannelName.substring(1);
+    }
+    normalizedChannelName = normalizedChannelName.toLowerCase();
+
+    // Try to get from cache first
+    try {
+      const cachedChannel: WorkspaceChannel | null =
+        await this.getChannelFromCache({
+          projectId: data.projectId,
+          channelName: normalizedChannelName,
+        });
+      if (cachedChannel) {
+        logger.debug("Channel found in cache:");
+        logger.debug(cachedChannel);
+        return cachedChannel;
+      }
+    } catch (error) {
+      logger.error("Error getting channel from cache, falling back to API:");
+      logger.error(error);
+    }
+
+    let cursor: string | undefined = undefined;
+    const maxPages: number = 10; // Limit search to prevent excessive API calls
+    let pageCount: number = 0;
+
+    do {
+      const requestBody: JSONObject = {
+        limit: 200, // Use smaller limit for faster searches
+        types: "public_channel,private_channel",
+      };
+
+      if (cursor) {
+        requestBody["cursor"] = cursor;
+      }
+
+      const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+        await API.post<JSONObject>(
+          URL.fromString("https://slack.com/api/conversations.list"),
+          requestBody,
+          {
+            Authorization: `Bearer ${data.authToken}`,
+            ["Content-Type"]: "application/x-www-form-urlencoded",
+          },
+          {
+            retries: 3,
+            exponentialBackoff: true,
+          },
+        );
+
+      if (response instanceof HTTPErrorResponse) {
+        logger.error("Error response from Slack API:");
+        logger.error(response);
+        throw response;
+      }
+
+      // check for ok response
+      if ((response.jsonData as JSONObject)?.["ok"] !== true) {
+        logger.error("Invalid response from Slack API:");
+        logger.error(response.jsonData);
+        const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+          "error"
+        ] as string;
+        throw new BadRequestException("Error from Slack " + messageFromSlack);
+      }
+
+      for (const channel of (response.jsonData as JSONObject)[
+        "channels"
+      ] as Array<JSONObject>) {
+        if (!channel["id"] || !channel["name"]) {
+          continue;
+        }
+
+        const channelName: string = (channel["name"] as string).toLowerCase();
+        if (channelName === normalizedChannelName) {
+          logger.debug("Channel found:");
+          logger.debug(channel);
+
+          const foundChannel: WorkspaceChannel = {
+            id: channel["id"] as string,
+            name: channel["name"] as string,
+            workspaceType: WorkspaceType.Slack,
+          };
+
+          // Update cache if projectId is provided
+          if (data.projectId) {
+            try {
+              await this.updateChannelCache({
+                projectId: data.projectId,
+                channelName: normalizedChannelName,
+                channel: foundChannel,
+              });
+            } catch (error) {
+              logger.error("Error updating channel cache:");
+              logger.error(error);
+              // Don't fail the request if cache update fails
+            }
+          }
+
+          return foundChannel;
+        }
+      }
+
+      cursor = (
+        (response.jsonData as JSONObject)["response_metadata"] as JSONObject
+      )?.["next_cursor"] as string;
+      pageCount++;
+    } while (cursor && pageCount < maxPages);
+
+    logger.debug("Channel not found:");
+    return null;
+  }
+
   @CaptureSpan()
   public static override getDividerBlock(): JSONObject {
     return {
@@ -651,6 +870,7 @@ export default class SlackUtil extends WorkspaceBase {
   public static override async doesChannelExist(data: {
     authToken: string;
     channelName: string;
+    projectId: ObjectID;
   }): Promise<boolean> {
     // if channel name starts with #, remove it
     if (data.channelName && data.channelName.startsWith("#")) {
@@ -660,18 +880,15 @@ export default class SlackUtil extends WorkspaceBase {
     // convert channel name to lowercase
     data.channelName = data.channelName.toLowerCase();
 
-    // get channel id from channel name
-    const channels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
+    // Check if channel exists using optimized method
+    const channel: WorkspaceChannel | null =
+      await this.getWorkspaceChannelByName({
         authToken: data.authToken,
+        channelName: data.channelName,
+        projectId: data.projectId,
       });
 
-    // if this channel exists
-    if (channels[data.channelName]) {
-      return true;
-    }
-
-    return false;
+    return channel !== null;
   }
 
   @CaptureSpan()
@@ -679,6 +896,7 @@ export default class SlackUtil extends WorkspaceBase {
     workspaceMessagePayload: WorkspaceMessagePayload;
     authToken: string; // which auth token should we use to send.
     userId: string;
+    projectId: ObjectID;
   }): Promise<WorkspaceSendMessageResponse> {
     logger.debug("Sending message to Slack with data:");
     logger.debug(data);
@@ -690,24 +908,21 @@ export default class SlackUtil extends WorkspaceBase {
     logger.debug("Blocks generated from workspace message payload:");
     logger.debug(blocks);
 
-    const existingWorkspaceChannels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
-        authToken: data.authToken,
-      });
-
     const workspaceChannelsToPostTo: Array<WorkspaceChannel> = [];
 
+    // Resolve channel names efficiently
     for (let channelName of data.workspaceMessagePayload.channelNames) {
       if (channelName && channelName.startsWith("#")) {
         // trim # from channel name
         channelName = channelName.substring(1);
       }
 
-      let channel: WorkspaceChannel | null = null;
-
-      if (existingWorkspaceChannels[channelName]) {
-        channel = existingWorkspaceChannels[channelName]!;
-      }
+      const channel: WorkspaceChannel | null =
+        await this.getWorkspaceChannelByName({
+          authToken: data.authToken,
+          channelName: channelName,
+          projectId: data.projectId,
+        });
 
       if (channel) {
         workspaceChannelsToPostTo.push(channel);
@@ -868,6 +1083,7 @@ export default class SlackUtil extends WorkspaceBase {
   public static override async createChannel(data: {
     authToken: string;
     channelName: string;
+    projectId: ObjectID;
   }): Promise<WorkspaceChannel> {
     if (data.channelName && data.channelName.startsWith("#")) {
       data.channelName = data.channelName.substring(1);
@@ -935,6 +1151,20 @@ export default class SlackUtil extends WorkspaceBase {
 
     logger.debug("Channel created successfully:");
     logger.debug(channel);
+
+    // Cache the created channel
+    try {
+      await this.updateChannelCache({
+        projectId: data.projectId,
+        channelName: data.channelName,
+        channel: channel,
+      });
+    } catch (error) {
+      logger.error("Error caching created channel:");
+      logger.error(error);
+      // Don't fail the creation if caching fails
+    }
+
     return channel;
   }
 

package/Server/Utils/Workspace/Workspace.ts

@@ -194,6 +194,7 @@ export default class WorkspaceUtil {
         await WorkspaceUtil.getWorkspaceTypeUtil(workspaceType).sendMessage({
           userId: botUserId,
           authToken: projectAuthToken.authToken,
+          projectId: data.projectId,
           workspaceMessagePayload: messagePayloadByWorkspace,
         });
 
@@ -213,6 +214,7 @@ export default class WorkspaceUtil {
     projectOrUserAuthTokenForWorkspace: string;
     workspaceType: WorkspaceType;
     workspaceMessagePayload: WorkspaceMessagePayload;
+    projectId: ObjectID;
   }): Promise<WorkspaceSendMessageResponse> {
     logger.debug("postToWorkspaceChannels called with data:");
     logger.debug(data);
@@ -222,6 +224,7 @@ export default class WorkspaceUtil {
         userId: data.workspaceUserId,
         workspaceMessagePayload: data.workspaceMessagePayload,
         authToken: data.projectOrUserAuthTokenForWorkspace,
+        projectId: data.projectId,
       });
 
     logger.debug("Message posted to workspace channels successfully");

package/Server/Utils/Workspace/WorkspaceBase.ts

@@ -3,6 +3,7 @@ import HTTPResponse from "../../../Types/API/HTTPResponse";
 import Dictionary from "../../../Types/Dictionary";
 import NotImplementedException from "../../../Types/Exception/NotImplementedException";
 import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
 import WorkspaceChannelInvitationPayload from "../../../Types/Workspace/WorkspaceChannelInvitationPayload";
 import WorkspaceMessagePayload, {
   WorkspaceCheckboxBlock,
@@ -53,6 +54,7 @@ export default class WorkspaceBase {
   public static async doesChannelExist(_data: {
     authToken: string;
     channelName: string;
+    projectId: ObjectID;
   }): Promise<boolean> {
     throw new NotImplementedException();
   }
@@ -63,6 +65,7 @@ export default class WorkspaceBase {
     authToken: string;
     userId: string;
     sendMessageBeforeArchiving: WorkspacePayloadMarkdown;
+    projectId: ObjectID;
   }): Promise<void> {
     throw new NotImplementedException();
   }
@@ -121,6 +124,7 @@ export default class WorkspaceBase {
   public static async inviteUsersToChannels(data: {
     authToken: string;
     workspaceChannelInvitationPayload: WorkspaceChannelInvitationPayload;
+    projectId: ObjectID;
   }): Promise<void> {
     for (const channelName of data.workspaceChannelInvitationPayload
       .channelNames) {
@@ -129,6 +133,7 @@ export default class WorkspaceBase {
         channelName: channelName,
         workspaceUserIds:
           data.workspaceChannelInvitationPayload.workspaceUserIds,
+        projectId: data.projectId,
       });
     }
   }
@@ -138,12 +143,14 @@ export default class WorkspaceBase {
     authToken: string;
     channelName: string;
     workspaceUserIds: Array<string>;
+    projectId: ObjectID;
   }): Promise<void> {
     for (const userId of data.workspaceUserIds) {
       await this.inviteUserToChannelByChannelName({
         authToken: data.authToken,
         channelName: data.channelName,
         workspaceUserId: userId,
+        projectId: data.projectId,
       });
     }
   }
@@ -153,6 +160,7 @@ export default class WorkspaceBase {
     authToken: string;
     channelName: string;
     workspaceUserId: string;
+    projectId: ObjectID;
   }): Promise<void> {
     throw new NotImplementedException();
   }
@@ -175,6 +183,7 @@ export default class WorkspaceBase {
   public static async createChannelsIfDoesNotExist(_data: {
     authToken: string;
     channelNames: Array<string>;
+    projectId: ObjectID;
   }): Promise<Array<WorkspaceChannel>> {
     throw new NotImplementedException();
   }
@@ -192,6 +201,7 @@ export default class WorkspaceBase {
     workspaceMessagePayload: WorkspaceMessagePayload;
     authToken: string; // which auth token should we use to send.
     userId: string;
+    projectId: ObjectID;
   }): Promise<WorkspaceSendMessageResponse> {
     throw new NotImplementedException();
   }
@@ -207,6 +217,7 @@ export default class WorkspaceBase {
   public static async getWorkspaceChannelFromChannelName(_data: {
     authToken: string;
     channelName: string;
+    projectId: ObjectID;
   }): Promise<WorkspaceChannel> {
     throw new NotImplementedException();
   }
@@ -215,6 +226,7 @@ export default class WorkspaceBase {
   public static async createChannel(_data: {
     authToken: string;
     channelName: string;
+    projectId: ObjectID;
   }): Promise<WorkspaceChannel> {
     throw new NotImplementedException();
   }