@heroku-cli/heroku-connect-plugin 0.11.0

package/commands/connect-events/stream-delete.js

@@ -0,0 +1,33 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+module.exports = {
+  topic: 'connect-events:stream',
+  command: 'delete',
+  description: 'Delete an existing stream',
+  help: 'Delete an existing stream',
+  args: [
+    { name: 'stream' }
+  ],
+  flags: [
+    { name: 'resource', description: 'specific connection resource name', hasValue: true },
+    { name: 'confirm', hasValue: true }
+  ],
+  needsApp: true,
+  needsAuth: true,
+  run: cli.command(co.wrap(function * (context, heroku) {
+    yield cli.confirmApp(context.app, context.flags.confirm)
+
+    yield cli.action('deleting stream', co(function * () {
+      const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+      context.region = connection.region_url
+      const stream = yield api.withStream(context, connection, context.args.stream)
+      const response = yield api.request(context, 'DELETE', `/api/v3/streams/${stream.id}`)
+      if (response.status !== 204) {
+        throw new Error(response.data.message || 'unknown error')
+      }
+    }))
+  }))
+}

package/commands/connect-events/stream-state.js

@@ -0,0 +1,26 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+module.exports = {
+  topic: 'connect-events:stream',
+  command: 'state',
+  description: 'return a stream state',
+  help: 'return a stream state',
+  args: [
+    { name: 'stream' }
+  ],
+  flags: [
+    { name: 'resource', description: 'specific connection resource name', hasValue: true }
+  ],
+  needsApp: true,
+  needsAuth: true,
+  run: cli.command(co.wrap(function * (context, heroku) {
+    const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+    context.region = connection.region_url
+    const stream = yield api.withStream(context, connection, context.args.stream)
+
+    cli.log(stream.state)
+  }))
+}

package/index.js

@@ -0,0 +1,50 @@
+'use strict'
+exports.topics = [
+  {
+    name: 'connect',
+    description: 'manage connections for Heroku Connect'
+  },
+  {
+    name: 'connect:mapping',
+    description: 'manage mappings on a Heroku Connect addon'
+  },
+  {
+    name: 'connect-events',
+    description: 'manage connections for Heroku Connect Events Pilot'
+  },
+  {
+    name: 'connect-events:stream',
+    description: 'manage mappings on a Heroku Connect Events Pilot addon'
+  }
+]
+
+exports.commands = [
+  require('./commands/connect/info'),
+  require('./commands/connect/state'),
+  require('./commands/connect/import'),
+  require('./commands/connect/export'),
+  require('./commands/connect/pause'),
+  require('./commands/connect/resume'),
+  require('./commands/connect/recover'),
+  require('./commands/connect/sf-auth'),
+  require('./commands/connect/db-set'),
+  require('./commands/connect/diagnose'),
+  require('./commands/connect/mapping-state'),
+  require('./commands/connect/mapping-delete'),
+  require('./commands/connect/mapping-reload'),
+  require('./commands/connect/mapping-diagnose'),
+  require('./commands/connect/mapping-write-errors'),
+  require('./commands/connect/write-errors'),
+
+  // Connect Events
+  require('./commands/connect-events/info'),
+  require('./commands/connect-events/state'),
+  require('./commands/connect-events/pause'),
+  require('./commands/connect-events/resume'),
+  require('./commands/connect-events/recover'),
+  require('./commands/connect-events/sf-auth'),
+  require('./commands/connect-events/db-set'),
+  require('./commands/connect-events/stream-state'),
+  require('./commands/connect-events/stream-delete'),
+  require('./commands/connect-events/stream-create')
+]

package/lib/clients/connect.js

@@ -0,0 +1,29 @@
+const axios = require('axios')
+
+class ConnectClient {
+  constructor (context) {
+    this.client = axios.create({
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${context.auth.password}`,
+        'Heroku-Client': 'cli'
+      }
+    })
+  }
+
+  getDetails (connection) {
+    const detailUrl = connection.detail_url
+    return this.client.get(`${detailUrl}?deep=true`)
+  }
+
+  request ({ baseURL, method, url, data }) {
+    return this.client({
+      baseURL,
+      method,
+      url,
+      data
+    })
+  }
+}
+
+exports.ConnectClient = ConnectClient

package/lib/clients/discovery.js

@@ -0,0 +1,32 @@
+const axios = require('axios')
+const baseURL = process.env.CONNECT_DISCOVERY_SERVER || (process.env.CONNECT_ADDON === 'connectqa'
+  ? 'https://hc-central-qa.herokai.com'
+  : 'https://hc-central.heroku.com')
+
+class DiscoveryClient {
+  constructor (context) {
+    this.client = axios.create({
+      baseURL,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${context.auth.password}`,
+        'Heroku-Client': 'cli'
+      }
+    })
+  }
+
+  searchConnections (appName, resourceName, addonType) {
+    const resourceNameQueryParam = resourceName ? `&resource_name=${resourceName}` : ''
+    const addonTypeQueryParam = addonType ? `&addon_type=${addonType}` : ''
+    const url = `/connections?app=${appName}${resourceNameQueryParam}${addonTypeQueryParam}`
+    return this.client(url)
+  }
+
+  requestAppAccess (appName, addonType) {
+    const addonTypeQueryParam = addonType ? `?addon_type=${addonType}` : ''
+    const url = `/auth/${appName}${addonTypeQueryParam}`
+    return this.client({ url: url, method: 'POST' })
+  }
+}
+
+exports.DiscoveryClient = DiscoveryClient

package/lib/connect/api.js

@@ -0,0 +1,181 @@
+'use strict'
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+const { ConnectClient } = require('../clients/connect')
+const { DiscoveryClient } = require('../clients/discovery')
+
+exports.ADDON_TYPE_SYNC = 1
+exports.ADDON_TYPE_EVENTS = 2
+
+const request = exports.request = function (context, method, url, data) {
+  if (!context.region) {
+    throw new Error('Must provide region URL')
+  }
+  const connectClient = new ConnectClient(context)
+  return connectClient.request({
+    baseURL: context.region,
+    method,
+    url,
+    data
+  })
+}
+
+const withUserConnections = exports.withUserConnections = co.wrap(function * (context, appName, flags, allowNone, heroku, addonType) {
+  const connectClient = new ConnectClient(context)
+  const discoveryClient = new DiscoveryClient(context)
+
+  const searchResponse = yield discoveryClient.searchConnections(appName, context.flags.resource, addonType)
+  const connections = searchResponse.data.results
+
+  if (connections.length === 0) {
+    return yield Promise.resolve([])
+  }
+
+  const fetchConnectionDetailFuncs = connections.map(function (c) {
+    return co(function * () {
+      const response = yield connectClient.getDetails(c)
+      const mergedDetails = {
+        ...c,
+        ...response.data
+      }
+      return yield Promise.resolve(mergedDetails)
+    })
+  })
+
+  const aggregatedConnectionsData = yield Promise.all(fetchConnectionDetailFuncs)
+  return yield Promise.resolve(aggregatedConnectionsData)
+})
+
+const withConnection = exports.withConnection = function (context, heroku, addonType) {
+  return co(function * () {
+    const connectClient = new ConnectClient(context)
+    const discoveryClient = new DiscoveryClient(context)
+
+    const searchResponse = yield discoveryClient.searchConnections(context.app, context.flags.resource, addonType)
+    const connections = searchResponse.data.results
+
+    if (connections.length === 0) {
+      yield Promise.reject(Error('No connection(s) found'))
+    } else if (connections.length > 1) {
+      throw new Error("Multiple connections found. Please use '--resource' to specify a single connection by resource name. Use 'connect:info' to list the resource names.")
+    } else {
+      const match = connections[0]
+      const matchDetailResponse = yield connectClient.getDetails(match)
+      const matchWithDetails = {
+        ...match,
+        ...matchDetailResponse.data
+      }
+      return yield Promise.resolve(matchWithDetails)
+    }
+  })
+}
+
+const withMapping = exports.withMapping = function (connection, objectName) {
+  return co(function * () {
+    const objectNameLower = objectName.toLowerCase()
+    let mapping
+    connection.mappings.forEach(function (m) {
+      if (m.object_name.toLowerCase() === objectNameLower) {
+        mapping = m
+      }
+    })
+    if (mapping !== undefined) {
+      return yield Promise.resolve(mapping)
+    } else {
+      throw new Error(`No mapping configured for ${objectName}`)
+    }
+  })
+}
+
+exports.withStream = function (context, connection, objectName) {
+  return co(function * () {
+    if (!connection.streams) {
+      connection.streams = yield getStreams(context, connection)
+    }
+    const objectNameLower = objectName.toLowerCase()
+    let stream
+    connection.streams.forEach(function (s) {
+      if (s.object_name.toLowerCase() === objectNameLower) {
+        stream = s
+      }
+    })
+    if (stream !== undefined) {
+      return yield Promise.resolve(stream)
+    } else {
+      throw new Error(`No stream configured for ${objectName}`)
+    }
+  })
+}
+
+const getStreams = exports.getStreams = function (context, connection) {
+  return co(function * () {
+    const connectClient = new ConnectClient(context)
+    const response = yield connectClient.request({
+      baseURL: connection.region_url,
+      method: 'GET',
+      url: `${connection.detail_url}/streams`,
+      data: null
+    })
+    const streams = response.data.results
+    return yield Promise.resolve(streams)
+  })
+}
+
+exports.withStreams = function (context, connections) {
+  return co(function * () {
+    const fetchConnectionStreams = connections.map(function (c) {
+      return co(function * () {
+        c.streams = yield getStreams(context, c)
+        return yield Promise.resolve(c)
+      })
+    })
+    const aggregatedConnectionsResponse = yield Promise.all(fetchConnectionStreams)
+    return yield Promise.resolve(aggregatedConnectionsResponse)
+  })
+}
+
+exports.requestAppAccess = function (context, app, flags, allowNone, heroku, addonType) {
+  return co(function * () {
+    const discoveryClient = new DiscoveryClient(context)
+    const response = yield discoveryClient.requestAppAccess(app, addonType)
+    yield Promise.resolve(response.json)
+    return yield withUserConnections(context, app, flags, allowNone, heroku, addonType)
+  })
+}
+
+exports.getWriteErrors = co.wrap(function * (context, heroku) {
+  let url, action
+  const mappingName = context.args.name
+  const connection = yield withConnection(context, heroku)
+  context.region = connection.region_url
+  if (!mappingName) {
+    url = `/api/v3/connections/${connection.id}/errors`
+    action = `Retrieving write errors for ${connection.name}`
+  } else {
+    const mapping = yield withMapping(connection, mappingName)
+    url = `/api/v3/mappings/${mapping.id}/errors`
+    action = `Retrieving write errors for ${mappingName} on ${connection.name}`
+  }
+  const results = yield cli.action(action, co(function * () {
+    return yield request(context, 'GET', url)
+  }))
+  const errors = results.data
+
+  if (errors.count === 0) {
+    cli.log(cli.color.green('No write errors in the last 24 hours'))
+  } else {
+    if (context.flags.json) {
+      cli.styledJSON(errors.results)
+    } else {
+      cli.table(errors.results, {
+        columns: [
+          { key: 'id', label: 'Trigger Log ID' },
+          { key: 'table_name', label: 'Table Name' },
+          { key: 'record_id', label: 'Table ID' },
+          { key: 'message', label: 'Error Message' },
+          { key: 'created_at', label: 'Created' }
+        ]
+      })
+    }
+  }
+})

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@heroku-cli/heroku-connect-plugin",
+  "description": "Heroku Connect plugin for Heroku CLI",
+  "version": "0.11.0",
+  "author": "Heroku",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/heroku/heroku-connect-plugin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/heroku/heroku-connect-plugin/issues"
+  },
+  "keywords": [
+    "heroku-plugin"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "scripts": {
+    "test": "CONNECT_ADDON=connectqa mocha && standard",
+    "style-fix": "standard --fix"
+  },
+  "files": [
+    "/index.js",
+    "/lib",
+    "/commands"
+  ],
+  "dependencies": {
+    "@heroku/heroku-cli-util": "^8.0.14",
+    "axios": "^0.27.2",
+    "co": "4.6.0",
+    "heroku-client": "^3.0.6",
+    "inquirer": "^5.1.0"
+  },
+  "devDependencies": {
+    "mocha": "^10.7.0",
+    "mockdate": "^2.0.1",
+    "nock": "^13.5.4",
+    "sinon": "^18.0.0",
+    "standard": "^16.0.4",
+    "unexpected": "^12.0.5"
+  }
+}