now-travis

#! /usr/bin/env node

const github = require('octonode')
const spawn = require('cross-spawn')
const normalizeUrl = require('normalize-url')
const urlRegex = require('url-regex')
const awaitUrl = require('await-url')
const {fallbackLocale} = require('../config.json')

if (!process.env.CI || !process.env.TRAVIS) {
  throw new Error('Could not detect Travis CI environment')
}

// eslint-disable-next-line max-statements
async function deploy(context, sha) {
  if (isFork()) {
    console.log(`▲ Now ${context} deployment is skipped for forks...`)
    return
  }
  const {
    LOCALE: locale,
    NOW_TOKEN: nowToken,
    GH_TOKEN: githubToken,
  } = process.env

  if (!githubToken) {
    throw new Error('Missing required environment variable GH_TOKEN')
  }

  if (!nowToken) {
    throw new Error('Missing required environment variable NOW_TOKEN')
  }
  const {TRAVIS_REPO_SLUG, TRAVIS_BUILD_ID} = process.env
  let target_url = `https://travis-ci.org/${TRAVIS_REPO_SLUG}/builds/${TRAVIS_BUILD_ID}`

  const client = github.client(githubToken)
  const ghRepo = client.repo(process.env.TRAVIS_REPO_SLUG)

  const isProd = context === 'production'
  updateStatus({
    state: 'pending',
    description: `▲ Now ${context} deployment pending`,
  })

  const cliArgs = ['--token', nowToken, '--no-clipboard', '--public']
  safeLog('spawning shell with command:', `now ${cliArgs.join(' ')}`)
  const result = await spawnPromise('now', [
    '--token',
    nowToken,
    '--no-clipboard',
    '--public',
    '--static',
    '--name',
    `${locale}-glamorous`,
    `out/${locale}`,
  ]).catch(err => {
    onError(err)
    throw err
  })

  target_url = getUrl(result)

  updateStatus({
    state: 'pending',
    description: `▲ Now ${context} deployment build started...`,
  })

  console.log(
    `🤠 Alrighty, deploy started. Now we're going to ping ${target_url} until it's ready!`
  )

  // check on the site for ten minutes every 5 seconds
  await awaitUrl(target_url, {interval: 5000, tries: 120}).catch(err => {
    console.error('Error waiting for the deployment to be ready.')
    onError(err)
    throw err
  })

  console.log(`💪 it's up and ready!`)

  if (isProd) {
    await aliasDeploy()
  }

  console.log('🏁 all done!')
  updateStatus({
    state: 'success',
    description: `▲ Now ${context} deployment complete`,
  })

  function onError(err) {
    safeError(err)
    updateStatus({
      state: 'error',
      description: `▲ Now ${context} deployment failed. See Travis logs for details.`,
    })
  }

  function updateStatus(options) {
    const mergedOptions = Object.assign({context, target_url}, options)
    const {description, target_url: url} = mergedOptions
    console.log(`${description}: ${url}`)
    if (locale === fallbackLocale) {
      // we can't report status for more than one locale.
      ghRepo.status(sha, mergedOptions, logError('setting complete status'))
    }
  }

  function aliasDeploy() {
    // if we're production, then we need to alias things
    console.log(`↪️ We're building for production, so let's alias this!`)
    const prefix = locale === fallbackLocale ? '' : `${locale}.`
    const domain =  'glamorous.rocks'
    const alias = `${prefix}${domain}`
    const aliasArgs = ['alias', 'set', target_url, alias, '--token', nowToken]
    safeLog('spawning shell with command:', `now ${aliasArgs.join(' ')}`)
    return spawnPromise('now', aliasArgs)
  }

  function spawnPromise(...args) {
    return new Promise((resolve, reject) => {
      const child = spawn(...args)
      let stdout = ''
      let stderr = ''
      child.stdout.on('data', data => {
        stdout += data
        safeLog(String(data))
      })
      child.stderr.on('data', data => {
        safeError(String(data))
        stderr += String(safeify(data))
      })

      child.on('error', error => {
        onError(error)
        reject(safeify(error))
      })

      child.on('close', () => {
        if (stderr) {
          reject(stderr)
        } else {
          resolve(stdout)
        }
      })
    })
  }

  function safeLog(...args) {
    const safeArgs = args.map(s => safeify(s))
    console.log(...safeArgs)
  }

  function safeError(...args) {
    const safeArgs = args.map(s => safeify(s))
    console.error(...safeArgs)
  }

  function safeify(s, safed = []) {
    if (safed.indexOf(s) !== -1) {
      return 'CIRCULAR'
    }
    safed.push(s)
    if (typeof s === 'string') {
      return s
        .split(nowToken)
        .join('NOW_TOKEN')
        .split(githubToken)
        .join('GITHUB_TOKEN')
    } else if (typeof s === 'object' && s !== null) {
      return Object.keys(s).reduce((acc, k) => {
        acc[k] = safeify(s, safed)
        return acc
      }, {})
    } else {
      return s
    }
  }
}

const {TRAVIS_EVENT_TYPE, TRAVIS_PULL_REQUEST_SHA, TRAVIS_COMMIT} = process.env

switch (TRAVIS_EVENT_TYPE) {
  case 'pull_request': {
    deploy('staging', TRAVIS_PULL_REQUEST_SHA)
    break
  }
  case 'push': {
    deploy('production', TRAVIS_COMMIT)
    break
  }
  default: {
    console.log(`${TRAVIS_EVENT_TYPE} is not supported by now-travis`)
  }
}

function isFork() {
  const {TRAVIS_PULL_REQUEST_SLUG, TRAVIS_REPO_SLUG} = process.env
  if (!TRAVIS_PULL_REQUEST_SLUG) {
    return false
  }
  const [prOwner] = TRAVIS_PULL_REQUEST_SLUG.split('/')
  const [owner] = TRAVIS_REPO_SLUG.split('/')
  return owner !== prOwner
}

function getUrl(content) {
  const urls = content.match(urlRegex()) || []

  return urls.map(url => normalizeUrl(url.trim().replace(/\.+$/, '')))[0]
}

function logError(message) {
  return function onError(error) {
    if (error) {
      console.log(message, error)
    }
  }
}

// This is not transpiled
/*
  eslint
  no-console: 0,
  camelcase: 0,
  comma-dangle: [
    2,
    {
      arrays: 'always-multiline',
      objects: 'always-multiline',
      functions: 'never'
    }
  ]
 */