@heroku-cli/heroku-connect-plugin 0.11.5 → 0.12.0

package/commands/connect-events/resume.js

@@ -1,24 +1,28 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
+import * as api from '../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
 
-module.exports = {
-  topic: 'connect-events',
-  command: 'resume',
-  description: 'Resume a connection',
-  help: 'Resumes a paused connection',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
-    cli.action('resuming connection', co(function * () {
-      const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+export default class ConnectEventsResume extends Command {
+  static description = 'Resume a connection'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectEventsResume)
+    const context = {
+      app: flags.app,
+      flags,
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.action('resuming connection', (async function () {
+      const connection = await api.withConnection(context, this.heroku, api.ADDON_TYPE_EVENTS)
       context.region = connection.region_url
       const url = `/api/v3/kafka-connections/${connection.id}/actions/resume`
-      yield api.request(context, 'POST', url)
-    }))
-  }))
+      await api.request(context, 'POST', url)
+    }.bind(this))())
+  }
 }

package/commands/connect-events/{sf-auth.js → sf/auth.js}

@@ -1,12 +1,11 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
-const http = require('http')
+import * as api from '../../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
+import http from 'http'
 
 const LOCAL_PORT = 18000
 
-function callbackServer () {
+export function callbackServer () {
   return new Promise(function (resolve, reject) {
     // Create a local server that can receive the user after authoriztion is complete
     http.createServer(function (request, response) {
@@ -25,10 +24,10 @@ function callbackServer () {
   })
 }
 
-function * run (context, heroku) {
+async function authenticate (context, heroku) {
   let redir
-  yield cli.action('fetching authorizing URL', co(function * () {
-    const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+  await cli.action('fetching authorizing URL', (async function () {
+    const connection = await api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
     context.region = connection.region_url
 
     const url = `/api/v3/kafka-connections/${connection.id}/authorize_url`
@@ -47,29 +46,36 @@ function * run (context, heroku) {
       args.domain = context.flags.domain
     }
 
-    const response = yield api.request(context, 'POST', url, args)
+    const response = await api.request(context, 'POST', url, args)
     redir = response.data.redirect
 
-    yield cli.open(redir)
-  }))
+    await cli.open(redir)
+  })())
 
   cli.log("\nIf your browser doesn't open, please copy the following URL to proceed:\n" + redir + '\n')
 
-  yield cli.action('waiting for authorization', callbackServer())
+  await cli.action('waiting for authorization', callbackServer())
 }
 
-module.exports = {
-  topic: 'connect-events',
-  command: 'sf:auth',
-  description: 'Authorize access to Salesforce for your connection',
-  help: 'Opens a browser to authorize a connection to a Salesforce Org',
-  flags: [
-    { name: 'callback', char: 'c', description: 'final callback URL', hasValue: true },
-    { name: 'environment', char: 'e', description: '"production", "sandbox", or "custom" [defaults to "production"]', hasValue: true },
-    { name: 'domain', char: 'd', description: 'specify a custom login domain (if using a "custom" environment)', hasValue: true },
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(run))
+export default class ConnectEventsSfAuth extends Command {
+  static description = 'Authorize access to Salesforce for your connection'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    callback: flags.string({ char: 'c', description: 'final callback URL' }),
+    environment: flags.string({ char: 'e', description: '"production", "sandbox", or "custom" [defaults to "production"]' }),
+    domain: flags.string({ char: 'd', description: 'specify a custom login domain (if using a "custom" environment)' }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectEventsSfAuth)
+    const context = {
+      app: flags.app,
+      flags,
+      auth: { password: this.heroku.auth }
+    }
+
+    await authenticate(context, this.heroku)
+  }
 }

package/commands/connect-events/state.js

@@ -1,10 +1,9 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
+import * as api from '../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
 
-function * run (context, heroku) {
-  const connections = yield api.withUserConnections(context, context.app, context.flags, heroku, true, api.ADDON_TYPE_EVENTS)
+async function run (context, heroku) {
+  const connections = await api.withUserConnections(context, context.app, context.flags, heroku, true, api.ADDON_TYPE_EVENTS)
 
   if (context.flags.json) {
     cli.styledJSON(connections)
@@ -19,16 +18,23 @@ function * run (context, heroku) {
   }
 }
 
-module.exports = {
-  topic: 'connect-events',
-  command: 'state',
-  description: 'return the connection(s) state',
-  help: 'returns the state key of the selected connections',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true },
-    { name: 'json', description: 'print output as json', hasValue: false }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(run))
+export default class ConnectEventsState extends Command {
+  static description = 'return the connection(s) state'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    json: flags.boolean({ description: 'print output as json' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectEventsState)
+    const context = {
+      app: flags.app,
+      flags,
+      auth: { password: this.heroku.auth }
+    }
+
+    await run(context, this.heroku)
+  }
 }

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

@@ -0,0 +1,39 @@
+import * as api from '../../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+import cli from '@heroku/heroku-cli-util'
+
+export default class ConnectEventsStreamCreate extends Command {
+  static description = 'Create a stream'
+
+  static args = {
+    stream: Args.string()
+  }
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(ConnectEventsStreamCreate)
+    const context = {
+      app: flags.app,
+      flags,
+      args,
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.action('creating stream', (async function () {
+      const connection = await api.withConnection(context, this.heroku, api.ADDON_TYPE_EVENTS)
+      context.region = connection.region_url
+      const response = await api.request(
+        context, 'POST', `/api/v3/kafka-connections/${connection.id}/streams`,
+        { object_name: args.stream }
+      )
+      if (response.status !== 201) {
+        throw new Error(response.data.message || 'unknown error')
+      }
+    }.bind(this))())
+  }
+}

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

@@ -0,0 +1,40 @@
+import * as api from '../../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+import cli from '@heroku/heroku-cli-util'
+
+export default class ConnectEventsStreamDelete extends Command {
+  static description = 'Delete an existing stream'
+
+  static args = {
+    stream: Args.string()
+  }
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    confirm: flags.string()
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(ConnectEventsStreamDelete)
+    const context = {
+      app: flags.app,
+      flags,
+      args,
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.confirmApp(flags.app, flags.confirm)
+
+    await cli.action('deleting stream', (async function () {
+      const connection = await api.withConnection(context, this.heroku, api.ADDON_TYPE_EVENTS)
+      context.region = connection.region_url
+      const stream = await api.withStream(context, connection, args.stream)
+      const response = await api.request(context, 'DELETE', `/api/v3/streams/${stream.id}`)
+      if (response.status !== 204) {
+        throw new Error(response.data.message || 'unknown error')
+      }
+    }.bind(this))())
+  }
+}

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

@@ -0,0 +1,33 @@
+import * as api from '../../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+import cli from '@heroku/heroku-cli-util'
+
+export default class ConnectEventsStreamState extends Command {
+  static description = 'return a stream state'
+
+  static args = {
+    stream: Args.string()
+  }
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(ConnectEventsStreamState)
+    const context = {
+      app: flags.app,
+      flags,
+      args,
+      auth: { password: this.heroku.auth }
+    }
+
+    const connection = await api.withConnection(context, this.heroku, api.ADDON_TYPE_EVENTS)
+    context.region = connection.region_url
+    const stream = await api.withStream(context, connection, args.stream)
+
+    cli.log(stream.state)
+  }
+}

package/lib/clients/connect.js

@@ -1,4 +1,4 @@
-const axios = require('axios')
+import axios from 'axios'
 
 class ConnectClient {
   constructor (context) {
@@ -16,14 +16,15 @@ class ConnectClient {
     return this.client.get(`${detailUrl}?deep=true`)
   }
 
-  request ({ baseURL, method, url, data }) {
+  request ({ baseURL, method, url, data, params }) {
     return this.client({
       baseURL,
       method,
       url,
-      data
+      data,
+      params
     })
   }
 }
 
-exports.ConnectClient = ConnectClient
+export { ConnectClient }

package/lib/clients/discovery.js

@@ -1,4 +1,5 @@
-const axios = require('axios')
+import axios from 'axios'
+
 const baseURL = process.env.CONNECT_DISCOVERY_SERVER || (process.env.CONNECT_ADDON === 'connectqa'
   ? 'https://hc-central-qa.herokai.com'
   : 'https://hc-central.heroku.com')
@@ -29,4 +30,4 @@ class DiscoveryClient {
   }
 }
 
-exports.DiscoveryClient = DiscoveryClient
+export { DiscoveryClient }

package/lib/connect/api.js

@@ -1,13 +1,11 @@
-'use strict'
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
-const { ConnectClient } = require('../clients/connect')
-const { DiscoveryClient } = require('../clients/discovery')
+import cli from '@heroku/heroku-cli-util'
+import { ConnectClient } from '../clients/connect.js'
+import { DiscoveryClient } from '../clients/discovery.js'
 
-exports.ADDON_TYPE_SYNC = 1
-exports.ADDON_TYPE_EVENTS = 2
+export const ADDON_TYPE_SYNC = 1
+export const ADDON_TYPE_EVENTS = 2
 
-const request = exports.request = function (context, method, url, data) {
+export function request (context, method, url, data, params) {
   if (!context.region) {
     throw new Error('Must provide region URL')
   }
@@ -16,149 +14,129 @@ const request = exports.request = function (context, method, url, data) {
     baseURL: context.region,
     method,
     url,
-    data
+    data,
+    params
   })
 }
 
-const withUserConnections = exports.withUserConnections = co.wrap(function * (context, appName, flags, allowNone, heroku, addonType) {
+export async function withUserConnections (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 searchResponse = await discoveryClient.searchConnections(appName, context.flags.resource, addonType)
   const connections = searchResponse.data.results
 
   if (connections.length === 0) {
-    return yield Promise.resolve([])
+    return []
   }
 
-  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 fetchConnectionDetailFuncs = connections.map(async function (c) {
+    const response = await connectClient.getDetails(c)
+    return {
+      ...c,
+      ...response.data
+    }
   })
 
-  const aggregatedConnectionsData = yield Promise.all(fetchConnectionDetailFuncs)
-  return yield Promise.resolve(aggregatedConnectionsData)
-})
+  const aggregatedConnectionsData = await Promise.all(fetchConnectionDetailFuncs)
+  return aggregatedConnectionsData
+}
 
-const withConnection = exports.withConnection = function (context, heroku, addonType) {
-  return co(function * () {
-    const connectClient = new ConnectClient(context)
-    const discoveryClient = new DiscoveryClient(context)
+export async function withConnection (context, heroku, addonType) {
+  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
+  const searchResponse = await 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)
+  if (connections.length === 0) {
+    throw 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 = await connectClient.getDetails(match)
+    return {
+      ...match,
+      ...matchDetailResponse.data
     }
-  })
+  }
 }
 
-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}`)
+export async function withMapping (connection, objectName) {
+  const objectNameLower = objectName?.toLowerCase()
+  let mapping
+  connection.mappings.forEach(function (m) {
+    if (m.object_name.toLowerCase() === objectNameLower) {
+      mapping = m
     }
   })
+  if (mapping !== undefined) {
+    return 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}`)
+export async function withStream (context, connection, objectName) {
+  if (!connection.streams) {
+    connection.streams = await 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 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)
+export async function getStreams (context, connection) {
+  const connectClient = new ConnectClient(context)
+  const response = await connectClient.request({
+    baseURL: connection.region_url,
+    method: 'GET',
+    url: `${connection.detail_url}/streams`,
+    data: null
   })
+  return response.data.results
 }
 
-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)
+export async function withStreams (context, connections) {
+  const fetchConnectionStreams = connections.map(async function (c) {
+    c.streams = await getStreams(context, c)
+    return c
   })
+  return await Promise.all(fetchConnectionStreams)
 }
 
-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)
-  })
+export async function requestAppAccess (context, app, flags, allowNone, heroku, addonType) {
+  const discoveryClient = new DiscoveryClient(context)
+  await discoveryClient.requestAppAccess(app, addonType)
+  return await withUserConnections(context, app, flags, allowNone, heroku, addonType)
 }
 
-exports.getWriteErrors = co.wrap(function * (context, heroku) {
+export async function getWriteErrors (context, heroku) {
   let url, action
   const mappingName = context.args.name
-  const connection = yield withConnection(context, heroku)
+  const connection = await 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)
+    const mapping = await 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 results = await cli.action(action, (async function () {
+    return await request(context, 'GET', url)
+  })())
   const errors = results.data
 
   if (errors.count === 0) {
@@ -178,4 +156,4 @@ exports.getWriteErrors = co.wrap(function * (context, heroku) {
       })
     }
   }
-})
+}