@fabasoad/sarif-to-slack 0.2.2 → 0.2.4

package/.github/workflows/security.yml

@@ -11,6 +11,7 @@ jobs:
   sast:
     name: SAST
     permissions:
+      actions: read
       contents: read
       security-events: write
     uses: fabasoad/reusable-workflows/.github/workflows/wf-security-sast.yml@main

package/.github/workflows/send-sarif-to-slack.yml

@@ -34,6 +34,8 @@ on: # yamllint disable-line rule:truthy
           - "Trivy IaC (Error: 1, Note: 1)"
           - "Wiz Container (Error: 12, Warning: 369, Note: 191)"
           - "Wiz IaC (Warning: 5, Note: 5)"
+          - "Runs: 1, Extensions: 1, Results: 0"
+          - "Runs: 1, Extensions: 1, Results > 0"
           - "Runs: 1, Tools: 1, Results: 0"
           - "Runs: 2, Tools: 1, Results > 0"
           - "Runs: 2, Tools: 1, Results: 0"
@@ -174,6 +176,10 @@ jobs:
             value="wiz-iac.sarif"
           elif [ "${INPUT_SARIF}" = "Runs: 1, Tools: 1, Results: 0" ]; then
             value="runs-1-tools-1-results-0.sarif"
+          elif [ "${INPUT_SARIF}" = "Runs: 1, Extensions: 1, Results: 0" ]; then
+            value="runs-1-extensions-1-results-0.sarif"
+          elif [ "${INPUT_SARIF}" = "Runs: 1, Extensions: 1, Results > 0" ]; then
+            value="runs-1-extensions-1.sarif"
           elif [ "${INPUT_SARIF}" = "Runs: 2, Tools: 1, Results > 0" ]; then
             value="runs-2-tools-1.sarif"
           elif [ "${INPUT_SARIF}" = "Runs: 2, Tools: 1, Results: 0" ]; then

package/api-extractor.json

@@ -76,7 +76,7 @@
    *
    * DEFAULT VALUE: "crlf"
    */
-  // "newlineKind": "crlf",
+  "newlineKind": "lf",
 
   /**
    * Specifies how API Extractor sorts members of an enum when generating the .api.json file. By default, the output
@@ -85,7 +85,7 @@
    *
    * DEFAULT VALUE: "by-name"
    */
-  // "enumMemberOrder": "by-name",
+  "enumMemberOrder": "preserve",
 
   /**
    * Set to true when invoking API Extractor's test harness. When `testMode` is true, the `toolVersion` field in the

package/dist/index.cjs

@@ -0,0 +1,643 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CalculateResultsBy: () => CalculateResultsBy,
+  FooterType: () => FooterType,
+  GroupResultsBy: () => GroupResultsBy,
+  LogLevel: () => LogLevel,
+  SarifToSlackService: () => SarifToSlackService
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/SarifToSlackService.ts
+var import_fs = require("fs");
+
+// src/Logger.ts
+var import_tslog = require("tslog");
+
+// src/types.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Silly"] = 0] = "Silly";
+  LogLevel2[LogLevel2["Trace"] = 1] = "Trace";
+  LogLevel2[LogLevel2["Debug"] = 2] = "Debug";
+  LogLevel2[LogLevel2["Info"] = 3] = "Info";
+  LogLevel2[LogLevel2["Warning"] = 4] = "Warning";
+  LogLevel2[LogLevel2["Error"] = 5] = "Error";
+  LogLevel2[LogLevel2["Fatal"] = 6] = "Fatal";
+  return LogLevel2;
+})(LogLevel || {});
+var FooterType = /* @__PURE__ */ ((FooterType2) => {
+  FooterType2["PlainText"] = "plain_text";
+  FooterType2["Markdown"] = "mrkdwn";
+  return FooterType2;
+})(FooterType || {});
+var GroupResultsBy = /* @__PURE__ */ ((GroupResultsBy2) => {
+  GroupResultsBy2[GroupResultsBy2["ToolName"] = 0] = "ToolName";
+  GroupResultsBy2[GroupResultsBy2["Run"] = 1] = "Run";
+  GroupResultsBy2[GroupResultsBy2["Total"] = 2] = "Total";
+  return GroupResultsBy2;
+})(GroupResultsBy || {});
+var CalculateResultsBy = /* @__PURE__ */ ((CalculateResultsBy2) => {
+  CalculateResultsBy2[CalculateResultsBy2["Level"] = 0] = "Level";
+  CalculateResultsBy2[CalculateResultsBy2["Severity"] = 1] = "Severity";
+  return CalculateResultsBy2;
+})(CalculateResultsBy || {});
+
+// src/Logger.ts
+var Logger = class _Logger {
+  static DEFAULT_LOG_LEVEL = 3 /* Info */;
+  static DEFAULT_LOG_TEMPLATE = "[{{logLevelName}}] [{{name}}] {{dateIsoStr}} ";
+  static DEFAULT_LOG_COLORED = true;
+  static instance;
+  static initialize(opts) {
+    if (!_Logger.instance) {
+      _Logger.instance = new import_tslog.Logger({
+        name: "@fabasoad/sarif-to-slack",
+        minLevel: process.env.ACTIONS_STEP_DEBUG === "true" ? 0 /* Silly */ : opts?.level ?? _Logger.DEFAULT_LOG_LEVEL,
+        type: "pretty",
+        prettyLogTimeZone: "UTC",
+        prettyLogTemplate: opts?.template ?? _Logger.DEFAULT_LOG_TEMPLATE,
+        stylePrettyLogs: opts?.colored ?? _Logger.DEFAULT_LOG_COLORED
+      });
+    }
+  }
+  static warn(...args) {
+    _Logger.instance.warn(...args);
+  }
+  static info(...args) {
+    _Logger.instance.info(...args);
+  }
+  static debug(...args) {
+    _Logger.instance.debug(...args);
+  }
+};
+
+// src/Processors.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function processColor(color) {
+  switch (color) {
+    case "success":
+      Logger.info(`Converting "${color}" to #008000`);
+      return "#008000";
+    case "failure":
+      Logger.info(`Converting "${color}" to #ff0000`);
+      return "#ff0000";
+    case "cancelled":
+      Logger.info(`Converting "${color}" to #0047ab`);
+      return "#0047ab";
+    case "skipped":
+      Logger.info(`Converting "${color}" to #808080`);
+      return "#808080";
+    default:
+      Logger.debug(`"${color}" color is not a CI status identifier. Returning as is.`);
+      return color;
+  }
+}
+function processSarifPath(sarifPath) {
+  if (!fs.existsSync(sarifPath)) {
+    throw new Error(`"sarif-path" does not exist: ${sarifPath}`);
+  }
+  const sarifStats = fs.statSync(sarifPath);
+  if (sarifStats.isDirectory()) {
+    Logger.info(`"sarif-path" is a directory: ${sarifPath}`);
+    const files = fs.readdirSync(sarifPath);
+    const filteredFiles = files.filter(
+      (file) => path.extname(file).toLowerCase() === ".sarif"
+    );
+    Logger.info(`Found ${filteredFiles.length} SARIF files in ${sarifPath} directory`);
+    Logger.debug(`Filtered SARIF files: ${filteredFiles.join(", ")}`);
+    return filteredFiles.map((file) => path.join(sarifPath, file));
+  }
+  if (sarifStats.isFile()) {
+    Logger.info(`"sarif-path" is a file: ${sarifPath}`);
+    return [sarifPath];
+  }
+  throw new Error(`"sarif-path" is neither a file nor a directory: ${sarifPath}`);
+}
+
+// src/SlackMessageBuilder.ts
+var import_webhook = require("@slack/webhook");
+
+// src/version.ts
+var LIB_VERSION = "0.2.4";
+
+// src/model/SarifModelPerSarif.ts
+var import_immutable2 = require("immutable");
+
+// src/utils/SarifUtils.ts
+function findToolComponentByResult(run, result) {
+  let tool;
+  if (result?.rule?.toolComponent?.index != null) {
+    tool = run.tool.extensions?.[result.rule.toolComponent.index];
+  }
+  if (!tool) {
+    tool = run.tool.driver;
+  }
+  return tool;
+}
+function findRuleByResult(run, result) {
+  const ruleData = {};
+  if (result.rule) {
+    if (result.rule?.index != null) {
+      ruleData.index = result.rule.index;
+    }
+    if (result.rule?.id) {
+      ruleData.id = result.rule.id;
+    }
+  }
+  if (ruleData.index == null && result.ruleIndex != null) {
+    ruleData.index = result.ruleIndex;
+  }
+  if (!ruleData.id && result.ruleId) {
+    ruleData.id = result.ruleId;
+  }
+  const tool = findToolComponentByResult(run, result);
+  if (ruleData.index != null && tool?.rules && ruleData.index < tool.rules.length) {
+    return tool.rules[ruleData.index];
+  }
+  if (ruleData.id && tool?.rules) {
+    return tool.rules.find(
+      (r) => r.id === ruleData.id
+    );
+  }
+  return void 0;
+}
+function tryGetRulePropertyByResult(run, result, propertyName) {
+  const rule = findRuleByResult(run, result);
+  if (rule && rule.properties && propertyName in rule.properties) {
+    return rule.properties[propertyName];
+  }
+  return void 0;
+}
+
+// src/model/types.ts
+var SecuritySeverityOrder = [
+  "Critical" /* Critical */,
+  "High" /* High */,
+  "Medium" /* Medium */,
+  "Low" /* Low */,
+  "None" /* None */,
+  "Unknown" /* Unknown */
+];
+var SecurityLevelOrder = [
+  "Error" /* Error */,
+  "Warning" /* Warning */,
+  "Note" /* Note */,
+  "Unknown" /* Unknown */
+];
+
+// src/model/SarifModelPerRun.ts
+var import_immutable = require("immutable");
+
+// src/utils/SortUtils.ts
+function sortSecurityLevelMap(map) {
+  return map.sortBy(
+    (_, level) => level,
+    (a, b) => SecurityLevelOrder.indexOf(a) - SecurityLevelOrder.indexOf(b)
+  ).asImmutable();
+}
+function sortSecuritySeverityMap(map) {
+  return map.sortBy(
+    (_, severity) => severity,
+    (a, b) => SecuritySeverityOrder.indexOf(a) - SecuritySeverityOrder.indexOf(b)
+  ).asImmutable();
+}
+
+// src/model/SarifModelPerRun.ts
+var SarifModelPerRun = class {
+  toolName;
+  _securitySeverityMap;
+  _securityLevelMap;
+  constructor(run) {
+    this.toolName = findToolComponentByResult(run, run.results?.[0]).name;
+    this._securitySeverityMap = (0, import_immutable.Map)().asMutable();
+    this._securityLevelMap = (0, import_immutable.Map)().asMutable();
+    this.buildSecuritySeverityMap(run);
+    this.buildSecurityLevelMap(run);
+  }
+  identifySecuritySeverity(score) {
+    if (score === void 0) {
+      return "Unknown" /* Unknown */;
+    }
+    if (score >= 9 && score <= 10) {
+      return "Critical" /* Critical */;
+    }
+    if (score >= 7) {
+      return "High" /* High */;
+    }
+    if (score >= 4) {
+      return "Medium" /* Medium */;
+    }
+    if (score >= 0.1) {
+      return "Low" /* Low */;
+    }
+    if (score == 0) {
+      return "None" /* None */;
+    }
+    Logger.warn(`Unsupported "${score}" security severity. Saving as "Unknown".`);
+    return "Unknown" /* Unknown */;
+  }
+  identifySecurityLevel(level) {
+    if (level === void 0) {
+      return "Unknown" /* Unknown */;
+    }
+    if (level.toLowerCase() === "error") {
+      return "Error" /* Error */;
+    }
+    if (level.toLowerCase() === "warning") {
+      return "Warning" /* Warning */;
+    }
+    if (level.toLowerCase() === "note") {
+      return "Note" /* Note */;
+    }
+    Logger.warn(`Unsupported ${level} security level. Saving as "Unknown".`);
+    return "Unknown" /* Unknown */;
+  }
+  buildSecuritySeverityMap(run) {
+    const results = run.results ?? [];
+    for (const result of results) {
+      const severity = this.identifySecuritySeverity(
+        tryGetRulePropertyByResult(run, result, "security-severity")
+      );
+      const count = this._securitySeverityMap.get(severity) || 0;
+      this._securitySeverityMap.set(severity, count + 1);
+    }
+  }
+  tryGetSecurityLevel(run, result) {
+    if (result.level) {
+      return result.level;
+    }
+    return tryGetRulePropertyByResult(run, result, "problem.severity");
+  }
+  buildSecurityLevelMap(run) {
+    const results = run.results ?? [];
+    for (const result of results) {
+      const level = this.identifySecurityLevel(
+        this.tryGetSecurityLevel(run, result)
+      );
+      const count = this._securityLevelMap.get(level) || 0;
+      this._securityLevelMap.set(level, count + 1);
+    }
+  }
+  get securitySeverityMap() {
+    return sortSecuritySeverityMap(this._securitySeverityMap);
+  }
+  get securityLevelMap() {
+    return sortSecurityLevelMap(this._securityLevelMap);
+  }
+};
+
+// src/model/SarifModelPerSarif.ts
+var SarifModelPerSarif = class {
+  sarifModelPerRunList;
+  constructor(sarif) {
+    this.sarifModelPerRunList = new Array();
+    this.buildRunsList(sarif);
+  }
+  buildRunsList(sarif) {
+    for (const run of sarif.runs) {
+      this.sarifModelPerRunList.push(new SarifModelPerRun(run));
+    }
+  }
+  groupByToolNameWithSecurityLevel() {
+    const result = /* @__PURE__ */ new Map();
+    for (const sarifModelPerRun of this.sarifModelPerRunList) {
+      if (!result.has(sarifModelPerRun.toolName)) {
+        result.set(sarifModelPerRun.toolName, (0, import_immutable2.Map)().asMutable());
+      }
+      for (const [k, v] of sarifModelPerRun.securityLevelMap.entries()) {
+        const count = result.get(sarifModelPerRun.toolName)?.get(k) || 0;
+        result.get(sarifModelPerRun.toolName)?.set(k, count + v);
+      }
+    }
+    for (const [k, v] of result) {
+      result.set(k, sortSecurityLevelMap(v));
+    }
+    return result;
+  }
+  groupByRunWithSecurityLevel() {
+    const result = new Array();
+    for (const sarifModelPerRun of this.sarifModelPerRunList) {
+      result.push({
+        toolName: sarifModelPerRun.toolName,
+        data: sarifModelPerRun.securityLevelMap
+      });
+    }
+    return result;
+  }
+  groupByTotalWithSecurityLevel() {
+    const result = (0, import_immutable2.Map)().asMutable();
+    for (const sarifModelPerRun of this.sarifModelPerRunList) {
+      for (const [k, v] of sarifModelPerRun.securityLevelMap.entries()) {
+        const count = result.get(k) || 0;
+        result.set(k, count + v);
+      }
+    }
+    return sortSecurityLevelMap(result);
+  }
+  groupByToolNameWithSecuritySeverity() {
+    const result = /* @__PURE__ */ new Map();
+    for (const sarifModelPerRun of this.sarifModelPerRunList) {
+      if (!result.has(sarifModelPerRun.toolName)) {
+        result.set(sarifModelPerRun.toolName, (0, import_immutable2.Map)().asMutable());
+      }
+      for (const [k, v] of sarifModelPerRun.securitySeverityMap.entries()) {
+        const count = result.get(sarifModelPerRun.toolName)?.get(k) || 0;
+        result.get(sarifModelPerRun.toolName)?.set(k, count + v);
+      }
+    }
+    for (const [k, v] of result.entries()) {
+      result.set(k, sortSecuritySeverityMap(v));
+    }
+    return result;
+  }
+  groupByRunWithSecuritySeverity() {
+    const result = new Array();
+    for (const sarifModelPerRun of this.sarifModelPerRunList) {
+      result.push({
+        toolName: sarifModelPerRun.toolName,
+        data: sarifModelPerRun.securitySeverityMap
+      });
+    }
+    return result;
+  }
+  groupByTotalWithSecuritySeverity() {
+    const result = (0, import_immutable2.Map)().asMutable();
+    for (const sarifModelPerRun of this.sarifModelPerRunList) {
+      for (const [k, v] of sarifModelPerRun.securitySeverityMap.entries()) {
+        const count = result.get(k) || 0;
+        result.set(k, count + v);
+      }
+    }
+    return sortSecuritySeverityMap(result);
+  }
+  listToolNames() {
+    const toolNames = /* @__PURE__ */ new Set();
+    for (const sarifModelPerRun of this.sarifModelPerRunList) {
+      toolNames.add(sarifModelPerRun.toolName);
+    }
+    return toolNames;
+  }
+};
+
+// src/SlackMessageBuilder.ts
+var SlackMessageBuilder = class {
+  webhook;
+  gitHubServerUrl;
+  color;
+  sarifModelPerSarif;
+  output;
+  header;
+  footer;
+  actor;
+  runId;
+  sarif;
+  constructor(url, opts) {
+    this.webhook = new import_webhook.IncomingWebhook(url, {
+      username: opts.username || "SARIF results",
+      icon_url: opts.iconUrl
+    });
+    this.gitHubServerUrl = process.env.GITHUB_SERVER_URL || "https://github.com";
+    this.color = opts.color;
+    this.sarif = opts.sarif;
+    this.sarifModelPerSarif = new SarifModelPerSarif(opts.sarif);
+    this.output = opts.output || {
+      groupBy: 0 /* ToolName */,
+      calculateBy: 0 /* Level */
+    };
+  }
+  withHeader(header) {
+    this.header = {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: header || process.env.GITHUB_REPOSITORY || "SARIF results"
+      }
+    };
+  }
+  withActor(actor) {
+    this.actor = actor || process.env.GITHUB_ACTOR;
+  }
+  withRun() {
+    this.runId = process.env.GITHUB_RUN_ID;
+  }
+  withFooter(text, type) {
+    const repoName = "fabasoad/sarif-to-slack";
+    const element = text ? { type: type || "plain_text" /* PlainText */, text } : { type: "mrkdwn" /* Markdown */, text: `Generated by <${this.gitHubServerUrl}/${repoName}|@${repoName}@${LIB_VERSION}>` };
+    this.footer = {
+      type: "context",
+      elements: [element]
+    };
+  }
+  async send() {
+    const blocks = [];
+    if (this.header) {
+      blocks.push(this.header);
+    }
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: this.buildText()
+      }
+    });
+    if (this.footer) {
+      blocks.push(this.footer);
+    }
+    const { text } = await this.webhook.send({
+      attachments: [{ color: this.color, blocks }]
+    });
+    return text;
+  }
+  buildText() {
+    const text = [];
+    if (this.actor) {
+      const actorUrl = `${this.gitHubServerUrl}/${this.actor}`;
+      text.push(`_Triggered by <${actorUrl}|${this.actor}>_`);
+    }
+    text.push(this.composeSummary());
+    if (this.runId) {
+      let runText = "Job ";
+      if (process.env.GITHUB_REPOSITORY) {
+        runText += `<${this.gitHubServerUrl}/${process.env.GITHUB_REPOSITORY}/actions/runs/${this.runId}|#${this.runId}>`;
+      } else {
+        runText += `#${this.runId}`;
+      }
+      text.push(runText);
+    }
+    return text.join("\n\n");
+  }
+  composeSummaryWith(map, resultProcessor = (result) => result) {
+    const stats = new Array();
+    for (const [key, count] of map.entries()) {
+      stats.push(`*${key}*: ${count}`);
+    }
+    return resultProcessor(
+      stats.length == 0 ? "No issues found" : stats.join(", ")
+    );
+  }
+  composeSummary() {
+    const summaries = new Array();
+    switch (this.output.groupBy) {
+      case 0 /* ToolName */: {
+        const dataGroupedByToolName = this.output.calculateBy === 0 /* Level */ ? this.sarifModelPerSarif.groupByToolNameWithSecurityLevel() : this.sarifModelPerSarif.groupByToolNameWithSecuritySeverity();
+        for (const [toolName, map] of dataGroupedByToolName.entries()) {
+          summaries.push(this.composeSummaryWith(
+            map,
+            (result) => `*${toolName}*
+${result}`
+          ));
+        }
+        break;
+      }
+      case 1 /* Run */: {
+        const dataGroupedByRun = this.output.calculateBy === 0 /* Level */ ? this.sarifModelPerSarif.groupByRunWithSecurityLevel() : this.sarifModelPerSarif.groupByRunWithSecuritySeverity();
+        for (let i = 0; i < dataGroupedByRun.length; i++) {
+          const { data, toolName } = dataGroupedByRun[i];
+          summaries.push(this.composeSummaryWith(
+            data,
+            (result) => `_[Run ${i + 1}]_: *${toolName}*
+${result}`
+          ));
+        }
+        break;
+      }
+      default: {
+        const dataTotal = this.output.calculateBy === 0 /* Level */ ? this.sarifModelPerSarif.groupByTotalWithSecurityLevel() : this.sarifModelPerSarif.groupByTotalWithSecuritySeverity();
+        const toolNames = this.sarifModelPerSarif.listToolNames();
+        summaries.push(this.composeSummaryWith(
+          dataTotal,
+          (result) => `*${Array.from(toolNames).join("*, *")}*
+${result}`
+        ));
+        break;
+      }
+    }
+    return summaries.join("\n\n");
+  }
+};
+
+// src/SarifToSlackService.ts
+async function initialize(opts) {
+  const slackMessages = /* @__PURE__ */ new Map();
+  const sarifFiles = processSarifPath(opts.sarifPath);
+  if (sarifFiles.length === 0) {
+    throw new Error(`No SARIF files found at the provided path: ${opts.sarifPath}`);
+  }
+  for (const sarifFile of sarifFiles) {
+    const jsonString = await import_fs.promises.readFile(sarifFile, "utf8");
+    const messageBuilder = new SlackMessageBuilder(opts.webhookUrl, {
+      username: opts.username,
+      iconUrl: opts.iconUrl,
+      color: processColor(opts.color),
+      sarif: JSON.parse(jsonString),
+      output: opts.output
+    });
+    if (opts.header?.include) {
+      messageBuilder.withHeader(opts.header?.value);
+    }
+    if (opts.footer?.include) {
+      messageBuilder.withFooter(opts.footer?.value, opts.footer?.type);
+    }
+    if (opts.actor?.include) {
+      messageBuilder.withActor(opts.actor?.value);
+    }
+    if (opts.run?.include) {
+      messageBuilder.withRun();
+    }
+    slackMessages.set(sarifFile, messageBuilder);
+  }
+  return slackMessages;
+}
+var SarifToSlackService = class _SarifToSlackService {
+  _slackMessages;
+  constructor() {
+    this._slackMessages = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Gets the Slack messages prepared for each SARIF file.
+   * @returns A read-only map where keys are SARIF file paths and values are SlackMessage instances.
+   * @public
+   */
+  get slackMessages() {
+    return this._slackMessages;
+  }
+  /**
+   * Creates an instance of SarifToSlackService.
+   * @param opts - Options for the service, including webhook URL, SARIF path, and other configurations.
+   * @returns A promise that resolves to an instance of SarifToSlackService.
+   * @throws Error if no SARIF files are found at the provided path.
+   * @public
+   */
+  static async create(opts) {
+    Logger.initialize(opts.log);
+    const instance = new _SarifToSlackService();
+    const map = await initialize(opts);
+    map.forEach((val, key) => instance._slackMessages.set(key, val));
+    return instance;
+  }
+  /**
+   * Sends all prepared Slack messages.
+   * @returns A promise that resolves when all messages have been sent.
+   * @throws Error if a Slack message was not prepared for a SARIF path.
+   * @public
+   */
+  async sendAll() {
+    for (const sarifPath of this._slackMessages.keys()) {
+      await this.send(sarifPath);
+    }
+  }
+  /**
+   * Sends a Slack message for a specific SARIF path.
+   * @param sarifPath - The path of the SARIF file for which the message should be sent.
+   * @returns A promise that resolves when the message has been sent.
+   * @throws Error if a Slack message was not prepared for the given SARIF path.
+   * @public
+   */
+  async send(sarifPath) {
+    const message = this._slackMessages.get(sarifPath);
+    if (!message) {
+      throw new Error(`Slack message was not prepared for SARIF path: ${sarifPath}.`);
+    }
+    const text = await message.send();
+    Logger.info(`Message sent for ${sarifPath} file. Status:`, text);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CalculateResultsBy,
+  FooterType,
+  GroupResultsBy,
+  LogLevel,
+  SarifToSlackService
+});