slack.js

'use strict'

const fetch = require('node-fetch'),
  {
    getOption,
    raiseForStatus,
    getEnvNs,
    channelFormatter,
  } = require('../util'),
  {
    SLACK_WEBHOOK_URL,
    SLACK_MESSAGE_KEY,
  } = require('../constants'),
  { createLogger, logTrace } = require('../logger')

const logger = createLogger('slack'),
  MRKDWN_ESCAPE_REGEX = /(\\&)|(\\<)|(\\>)/gui,
  MRKDWN_ESCAPE_REPLACEMENTS = ['&amp;', '&lt;', '&gt;'],
  MESSAGE = `
{{ REPORT_NAME }}

\`\`\`
{{ RESULTS_CSV_FORMATTED }}
\`\`\`
`

function escapeMrkdwn(str) {
  return str.replace(
    MRKDWN_ESCAPE_REGEX,
    (s, ...args) => {
      for (let index = 0; index < args.length; index += 1) {
        if (args[index]) {
          return MRKDWN_ESCAPE_REPLACEMENTS[index]
        }
      }
      return s
    },
  )
}

function formatText(
  context,
  report,
  publishConfig,
  channelConfig,
  output,
) {
  const message = getOption(
    channelConfig,
    SLACK_MESSAGE_KEY,
    null,
    MESSAGE,
  )

  return channelFormatter(
    context,
    report,
    publishConfig,
    channelConfig,
    output,
  )(message)
}


function buildHeaders(headers = {}) {
  return {
    'Content-Type': 'application/json',
    ...headers,
  }
}

async function post(webhookUrl, message, options = { headers: {} }) {
  logTrace(logger, log => {
    log({ message }, 'Slack Request:')
  })

  const response = await fetch(webhookUrl, {
    headers: buildHeaders(options.headers),
    method: 'POST',
    body: message,
  })

  raiseForStatus(response)

  const responseText = await response.text()

  logTrace(logger, log => {
    log({ response: responseText }, 'Slack Response:')
  })

  if (responseText !== 'ok') {
    logger.error(
      `Slack Webhook post error: ${responseText}`,
    )
    throw new Error(
      `Slack Webhook post error: ${responseText}`,
      message,
      responseText,
    )
  }

  return responseText
}

async function buildMessage(
  context,
  report,
  publishConfig,
  channelConfig,
  output,
) {

  if (channelConfig.passThrough) {
    return await output.render(context, report, channelConfig)
  }

  /*
   * Set the message text to the rendered output with any special mrkdwn
   * characters escaped.
   */
  return JSON.stringify({
    text: escapeMrkdwn(
      formatText(
        context,
        report,
        publishConfig,
        channelConfig,
        await output.render(
          context,
          report,
          channelConfig,
        ),
      ),
    ),
  })
}

async function postToSlack(
  context,
  manifest,
  report,
  publishConfig,
  channelConfig,
  output,
) {
  const reportName = report.name || report.id

  /*
   * This channel only supports Slack webhooks, not the API. Files can not be
   * posted via the webhook so if this is a file, warn and exit.
   */
  if (output.isFile()) {
    logger.warn(
      `Skipping output for report ${reportName} because Slack webhook does not support file attachments.`,
    )
    return
  }

  /*
   * Check to ensure we have a Slack webhook URL. We only support getting this
   * from the environment because it has a key in it.
   */
  const webhookUrl = getEnvNs(context, SLACK_WEBHOOK_URL)

  if (!webhookUrl) {
    throw new Error(`Missing Slack webhook URL for report ${reportName}.`)
  }

  /*
   * Post the message to the Slack webhook URL.
   */
  await post(
    webhookUrl,
    await buildMessage(
      context,
      report,
      publishConfig,
      channelConfig,
      output,
    ),
  )
}

module.exports = {
  publish: postToSlack,
  getChannelDefaults: () => ({}),
}