@oneuptime/common 13.0.8 → 14.0.0

package/build/dist/Server/Utils/Workspace/Slack/Slack.js

@@ -20,7 +20,7 @@ import CaptureSpan from "../../Telemetry/CaptureSpan";
 import BadDataException from "../../../../Types/Exception/BadDataException";
 import WorkspaceProjectAuthTokenService from "../../../Services/WorkspaceProjectAuthTokenService";
 import SSRFProtection from "../../SSRFProtection";
-export default class SlackUtil extends WorkspaceBase {
+class SlackUtil extends WorkspaceBase {
     static isValidSlackIncomingWebhookUrl(incomingWebhookUrl) {
         /*
          * Host AND path prefix. The host check is what stops SSRF; the "/services/"
@@ -874,7 +874,7 @@ export default class SlackUtil extends WorkspaceBase {
                     }
                 }
                 // Slack has a limit of 50 blocks per message. Split into batches if needed.
-                const maxBlocksPerMessage = 50;
+                const maxBlocksPerMessage = SlackUtil.MAX_BLOCKS_PER_MESSAGE;
                 let lastThread;
                 if (blocks.length <= maxBlocksPerMessage) {
                     lastThread = await this.sendPayloadBlocksToChannel({
@@ -1407,28 +1407,311 @@ export default class SlackUtil extends WorkspaceBase {
             },
             blocks: this.getBlocksFromWorkspaceMessagePayload({
                 messageBlocks: data.payloadModalBlock.blocks,
+                // A view takes twice as many blocks as a message.
+                maxBlocks: SlackUtil.MAX_BLOCKS_PER_MODAL,
             }),
         };
         logger.debug("Modal block generated:", {});
         logger.debug(modalBlock, {});
         return modalBlock;
     }
+    static getBlocksFromWorkspaceMessagePayload(data) {
+        var _a, _b;
+        const maxBlocks = (_a = data.maxBlocks) !== null && _a !== void 0 ? _a : SlackUtil.MAX_BLOCKS_PER_MESSAGE;
+        /*
+         * A markdown payload is the one block whose size we do not control: it
+         * carries whatever the incident or alert says, root cause included, and
+         * a section holds at most 3000 characters. So here it may expand into
+         * several consecutive sections (see getMarkdownBlocks). Every other
+         * block type still goes through the base class one block at a time, so
+         * it renders exactly as before — one block, or none for an unknown type.
+         *
+         * The extra sections must not take the message past maxBlocks, or Slack
+         * rejects all of it. So the other blocks are rendered first, every
+         * markdown payload is counted for the one section it always had, and
+         * only what is left of the budget is handed out as extra sections, in
+         * message order, so the body a caller puts first is the last thing to
+         * be cut short. A message that is already at the limit keeps one
+         * section per markdown payload, exactly as many blocks as before.
+         */
+        const renderedBlocks = [];
+        let blockCountBeforeSplitting = 0;
+        for (const messageBlock of data.messageBlocks) {
+            if (messageBlock._type === "WorkspacePayloadMarkdown") {
+                // Rendered in the second pass, once the budget is known.
+                renderedBlocks.push(null);
+                blockCountBeforeSplitting += 1;
+                continue;
+            }
+            const otherBlocks = super.getBlocksFromWorkspaceMessagePayload({
+                messageBlocks: [messageBlock],
+            });
+            renderedBlocks.push(otherBlocks);
+            blockCountBeforeSplitting += otherBlocks.length;
+        }
+        let spareBlocks = Math.max(0, maxBlocks - blockCountBeforeSplitting);
+        const blocks = [];
+        for (let index = 0; index < data.messageBlocks.length; index++) {
+            // Empty, not null, for a block of an unknown type — it stays dropped.
+            const rendered = (_b = renderedBlocks[index]) !== null && _b !== void 0 ? _b : null;
+            if (rendered !== null) {
+                blocks.push(...rendered);
+                continue;
+            }
+            const sections = this.getMarkdownBlocks({
+                payloadMarkdownBlock: data.messageBlocks[index],
+                maxSections: 1 +
+                    Math.min(spareBlocks, SlackUtil.MAX_SECTIONS_PER_MARKDOWN_BLOCK - 1),
+            });
+            spareBlocks -= sections.length - 1;
+            blocks.push(...sections);
+        }
+        return blocks;
+    }
+    /*
+     * One section block. Text over Slack's limit cannot be split here, so it
+     * is cut short with a note instead of being sent as a block Slack would
+     * reject; messages go through getBlocksFromWorkspaceMessagePayload, which
+     * splits it across sections. Text within the limit renders as it always
+     * has.
+     */
     static getMarkdownBlock(data) {
         logger.debug("Getting markdown block with data:", {});
         logger.debug(data, {});
-        const markdownBlock = {
-            type: "section",
-            text: {
-                type: "mrkdwn",
-                text: data.payloadMarkdownBlock.text
-                    ? SlackifyMarkdown(data.payloadMarkdownBlock.text)
-                    : "",
-            },
-        };
+        const markdownBlock = this.getMarkdownBlocks({
+            payloadMarkdownBlock: data.payloadMarkdownBlock,
+            maxSections: 1,
+        })[0];
         logger.debug("Markdown block generated:", {});
         logger.debug(markdownBlock, {});
         return markdownBlock;
     }
+    /*
+     * A markdown payload as consecutive section blocks, each within Slack's
+     * 3000-character limit. Text that fits is one section, byte for byte what
+     * a markdown payload has always rendered to (empty text included).
+     */
+    static getMarkdownBlocks(data) {
+        const text = data.payloadMarkdownBlock.text
+            ? SlackifyMarkdown(data.payloadMarkdownBlock.text)
+            : "";
+        const sectionTexts = this.splitSectionText({
+            text: text,
+            maxSections: data.maxSections,
+        });
+        if (sectionTexts.length > 1) {
+            logger.debug(`Markdown block of ${text.length} characters split into ${sectionTexts.length} sections.`, {});
+        }
+        return sectionTexts.map((sectionText) => {
+            return {
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: sectionText,
+                },
+            };
+        });
+    }
+    /*
+     * Splits slackified text into section texts of at most
+     * SECTION_TEXT_MAX_LENGTH characters, at the least disruptive places
+     * available:
+     *
+     *   1. between paragraphs (a blank line),
+     *   2. between list items, keeping an item together with the indented
+     *      bullets under it,
+     *   3. between lines,
+     *   4. and only inside a line that is on its own longer than the limit,
+     *      preferring a space there.
+     *
+     * The text between two sections is the newlines they were split at and
+     * nothing else, so the sections read back in order give every line of the
+     * original. A section that ends inside a ``` code block closes it and the
+     * next one reopens it.
+     *
+     * Beyond maxSections the rest is dropped and the last section ends with
+     * TRUNCATED_SECTION_NOTE. Text that fits is returned as it is.
+     */
+    static splitSectionText(data) {
+        var _a;
+        const maxLength = SlackUtil.SECTION_TEXT_MAX_LENGTH;
+        if (data.text.length <= maxLength) {
+            return [data.text];
+        }
+        const maxSections = Math.max(1, (_a = data.maxSections) !== null && _a !== void 0 ? _a : SlackUtil.MAX_SECTIONS_PER_MARKDOWN_BLOCK);
+        /*
+         * Any piece may need to reopen a code block at its start and close one
+         * at its end, so when the text has code blocks every piece leaves room
+         * for both.
+         */
+        const pieceMaxLength = data.text.includes(SlackUtil.CODE_FENCE)
+            ? maxLength -
+                SlackUtil.CODE_FENCE_REOPEN.length -
+                SlackUtil.CODE_FENCE_CLOSE.length
+            : maxLength;
+        let pieces = this.splitTextAtBoundaries(data.text, pieceMaxLength);
+        if (pieces.length === 0) {
+            // Nothing but whitespace — there is nothing to show.
+            return [""];
+        }
+        const isTruncated = pieces.length > maxSections;
+        if (isTruncated) {
+            pieces = pieces.slice(0, maxSections);
+            /*
+             * Shorten the last piece until the note fits after it, with the same
+             * boundary preferences — whole paragraphs, items or lines where it
+             * can.
+             */
+            const lastPiece = pieces[pieces.length - 1] || "";
+            pieces[pieces.length - 1] =
+                this.splitTextAtBoundaries(lastPiece, pieceMaxLength - SlackUtil.TRUNCATED_SECTION_NOTE.length)[0] || "";
+        }
+        const sections = [];
+        let isInsideCodeBlock = false;
+        for (let index = 0; index < pieces.length; index++) {
+            const piece = pieces[index] || "";
+            const isLastPiece = index === pieces.length - 1;
+            let section = isInsideCodeBlock
+                ? SlackUtil.CODE_FENCE_REOPEN + piece
+                : piece;
+            // An odd number of fences opens or closes a code block.
+            const fenceCount = piece.split(SlackUtil.CODE_FENCE).length - 1;
+            if (fenceCount % 2 === 1) {
+                isInsideCodeBlock = !isInsideCodeBlock;
+            }
+            /*
+             * The last piece of text that was not truncated ends where the
+             * original ends, so a code block still open there was never closed
+             * and is left alone.
+             */
+            if (isInsideCodeBlock && (!isLastPiece || isTruncated)) {
+                section += SlackUtil.CODE_FENCE_CLOSE;
+            }
+            if (isLastPiece && isTruncated) {
+                section += SlackUtil.TRUNCATED_SECTION_NOTE;
+            }
+            sections.push(section);
+        }
+        return sections;
+    }
+    /*
+     * Pieces of at most maxLength characters, split at the boundaries listed
+     * on splitSectionText. Each piece is trimmed of the newlines it was split
+     * at; a piece with nothing but whitespace is dropped.
+     */
+    static splitTextAtBoundaries(text, maxLength) {
+        const pieces = this.packSectionPieces({
+            units: text.split("\n\n"),
+            separator: "\n\n",
+            maxLength: maxLength,
+            splitOversizedUnit: (paragraph) => {
+                return this.packSectionPieces({
+                    units: this.groupIndentedLines(paragraph),
+                    separator: "\n",
+                    maxLength: maxLength,
+                    splitOversizedUnit: (lineGroup) => {
+                        return this.packSectionPieces({
+                            units: lineGroup.split("\n"),
+                            separator: "\n",
+                            maxLength: maxLength,
+                            splitOversizedUnit: (line) => {
+                                return this.hardCutLine(line, maxLength);
+                            },
+                        });
+                    },
+                });
+            },
+        });
+        return pieces
+            .map((piece) => {
+            return piece.replace(/^[\r\n]+|[\r\n]+$/g, "");
+        })
+            .filter((piece) => {
+            return piece.trim().length > 0;
+        });
+    }
+    /*
+     * Greedily joins units with the separator into pieces of at most
+     * maxLength. A unit that does not fit next to the piece being built
+     * starts a new piece rather than being broken up; only a unit longer than
+     * maxLength on its own is broken, by splitOversizedUnit. The last of its
+     * parts stays open, so the unit after it can still join it.
+     */
+    static packSectionPieces(data) {
+        var _a;
+        const pieces = [];
+        // null until the first unit, so an empty unit still keeps its separator.
+        let currentPiece = null;
+        for (const unit of data.units) {
+            if (currentPiece !== null) {
+                const joined = currentPiece + data.separator + unit;
+                if (joined.length <= data.maxLength) {
+                    currentPiece = joined;
+                    continue;
+                }
+                pieces.push(currentPiece);
+                currentPiece = null;
+            }
+            if (unit.length <= data.maxLength) {
+                currentPiece = unit;
+                continue;
+            }
+            const parts = data.splitOversizedUnit(unit);
+            pieces.push(...parts.slice(0, -1));
+            currentPiece = (_a = parts[parts.length - 1]) !== null && _a !== void 0 ? _a : null;
+        }
+        if (currentPiece !== null) {
+            pieces.push(currentPiece);
+        }
+        return pieces;
+    }
+    /*
+     * The lines of a paragraph, with every indented line attached to the line
+     * above it. slackify-markdown indents a nested bullet under its list item
+     * — the Affected Resources list puts a resource's namespace, workload and
+     * node there — so a split between groups never strands those bullets at
+     * the top of the next section, away from the item they describe.
+     */
+    static groupIndentedLines(paragraph) {
+        const groups = [];
+        for (const line of paragraph.split("\n")) {
+            const isIndented = line.startsWith(" ") || line.startsWith("\t");
+            const lastGroupIndex = groups.length - 1;
+            if (isIndented && lastGroupIndex >= 0) {
+                groups[lastGroupIndex] = (groups[lastGroupIndex] || "") + "\n" + line;
+                continue;
+            }
+            groups.push(line);
+        }
+        return groups;
+    }
+    /*
+     * Cuts a single line longer than maxLength. Each cut is made after the
+     * last space that still leaves the piece at least half full, so words stay
+     * whole where the line has spaces, and never between the two halves of a
+     * surrogate pair (an emoji), which would leave both pieces invalid.
+     */
+    static hardCutLine(line, maxLength) {
+        const pieces = [];
+        let rest = line;
+        while (rest.length > maxLength) {
+            let cutAt = maxLength;
+            const lastSpaceIndex = rest.lastIndexOf(" ", maxLength - 1);
+            if (lastSpaceIndex + 1 >= Math.ceil(maxLength / 2)) {
+                cutAt = lastSpaceIndex + 1;
+            }
+            else {
+                const charCodeBeforeCut = rest.charCodeAt(cutAt - 1);
+                if (charCodeBeforeCut >= 0xd800 && charCodeBeforeCut <= 0xdbff) {
+                    cutAt -= 1;
+                }
+            }
+            pieces.push(rest.slice(0, cutAt));
+            rest = rest.slice(cutAt);
+        }
+        pieces.push(rest);
+        return pieces;
+    }
     static async isUserInDirectMessageChannel(data) {
         var _a, _b, _c;
         // check of the user id is in the direct message channel id
@@ -1740,6 +2023,31 @@ export default class SlackUtil extends WorkspaceBase {
         return messages;
     }
 }
+/*
+ * Block Kit limits. A section's text may be at most 3000 characters, a
+ * message may carry at most 50 blocks and a modal view at most 100. Going
+ * over any of them makes Slack reject the whole message (invalid_blocks),
+ * not just the offending block.
+ */
+SlackUtil.SECTION_TEXT_MAX_LENGTH = 3000;
+SlackUtil.MAX_BLOCKS_PER_MESSAGE = 50;
+SlackUtil.MAX_BLOCKS_PER_MODAL = 100;
+/*
+ * How many sections one markdown payload may expand into — about 30,000
+ * characters, several times the longest incident or alert body we send.
+ * The 50-block ceiling alone would allow 150,000, but Slack also rejects a
+ * message whose blocks are too long overall (msg_blocks_too_long) without
+ * documenting where that starts, and text that long is better read in
+ * OneUptime anyway.
+ */
+SlackUtil.MAX_SECTIONS_PER_MARKDOWN_BLOCK = 10;
+// Ends the last section of a markdown payload that did not fit.
+SlackUtil.TRUNCATED_SECTION_NOTE = "\n\n_… (truncated — see OneUptime for the full text)_";
+// Closes and reopens a ``` code block that a section boundary cuts through.
+SlackUtil.CODE_FENCE = "```";
+SlackUtil.CODE_FENCE_CLOSE = "\n```";
+SlackUtil.CODE_FENCE_REOPEN = "```\n";
+export default SlackUtil;
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),
@@ -1938,12 +2246,24 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
 ], SlackUtil, "getModalBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Array)
+], SlackUtil, "getBlocksFromWorkspaceMessagePayload", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
 ], SlackUtil, "getMarkdownBlock", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Array)
+], SlackUtil, "getMarkdownBlocks", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),